AnalogTapeModel

commit cc1bc38b0716dbd8ea928dbbe513bba3320c0fcf
parent 56831989beb6f7c82c740cb9245d6359afa5321a
Author: jatin <[email protected]>
Date:   Fri,  6 Jan 2023 01:44:13 -0800

Draw modulatable sliders without that gnaryl dynamic_cast

Diffstat:
M
Plugin/Source/GUI/ModulatableSlider.cpp
 | 
123
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
M
Plugin/Source/GUI/ModulatableSlider.h
 | 
12
+++++++++++-

2 files changed, 134 insertions(+), 1 deletion(-)
diff --git a/Plugin/Source/GUI/ModulatableSlider.cpp b/Plugin/Source/GUI/ModulatableSlider.cpp
@@ -70,6 +70,129 @@ void ModulatableSlider::timerCallback()
     repaint();
 }
 
+
+void ModulatableSlider::drawRotarySlider (juce::Graphics& g, int x, int y, int width, int height, float sliderPos, float modSliderPos)
+{
+    int diameter = (width > height) ? height : width;
+    if (diameter < 16)
+        return;
+
+    juce::Point<float> centre ((float) x + std::floor ((float) width * 0.5f + 0.5f), (float) y + std::floor ((float) height * 0.5f + 0.5f));
+    diameter -= (diameter % 2 == 1) ? 9 : 8;
+    float radius = (float) diameter * 0.5f;
+    x = int (centre.x - radius);
+    y = int (centre.y - radius);
+
+    const auto bounds = juce::Rectangle<int> (x, y, diameter, diameter).toFloat();
+
+    auto b = sharedAssets->pointer->getBounds().toFloat();
+    sharedAssets->pointer->setTransform (AffineTransform::rotation (MathConstants<float>::twoPi * ((sliderPos - 0.5f) * 300.0f / 360.0f),
+                                                                    b.getCentreX(),
+                                                                    b.getCentreY()));
+
+    const auto alpha = isEnabled() ? 1.0f : 0.4f;
+    auto knobBounds = (bounds * 0.75f).withCentre (centre);
+    sharedAssets->knob->drawWithin (g, knobBounds, RectanglePlacement::stretchToFit, alpha);
+    sharedAssets->pointer->drawWithin (g, knobBounds, RectanglePlacement::stretchToFit, alpha);
+
+    static constexpr auto rotaryStartAngle = MathConstants<float>::pi * 1.2f;
+    static constexpr auto rotaryEndAngle = MathConstants<float>::pi * 2.8f;
+    const auto toAngle = rotaryStartAngle + modSliderPos * (rotaryEndAngle - rotaryStartAngle);
+    constexpr float arcFactor = 0.9f;
+
+    juce::Path valueArc;
+    valueArc.addPieSegment (bounds, rotaryStartAngle, rotaryEndAngle, arcFactor);
+    g.setColour (Colour (0xff595c6b).withMultipliedAlpha (alpha));
+    g.fillPath (valueArc);
+    valueArc.clear();
+
+    valueArc.addPieSegment (bounds, rotaryStartAngle, toAngle, arcFactor);
+    g.setColour (Colour (0xff9cbcbd).withMultipliedAlpha (alpha));
+    g.fillPath (valueArc);
+}
+
+void ModulatableSlider::drawLinearSlider (juce::Graphics& g, int x, int y, int width, int height, float sliderPos, float modSliderPos)
+{
+    const auto horizontal = isHorizontal();
+    auto trackWidth = juce::jmin (6.0f, horizontal ? (float) height * 0.25f : (float) width * 0.25f);
+
+    juce::Point startPoint (horizontal ? (float) x : (float) x + (float) width * 0.5f,
+                            horizontal ? (float) y + (float) height * 0.5f : (float) (height + y));
+
+    juce::Point endPoint (horizontal ? (float) (width + x) : startPoint.x,
+                          horizontal ? startPoint.y : (float) y);
+
+    juce::Path backgroundTrack;
+    backgroundTrack.startNewSubPath (startPoint);
+    backgroundTrack.lineTo (endPoint);
+
+    const auto alphaMult = isEnabled() ? 1.0f : 0.4f;
+    g.setColour (Colour (0xff595c6b).withAlpha (alphaMult));
+    g.strokePath (backgroundTrack, { trackWidth, juce::PathStrokeType::curved, juce::PathStrokeType::rounded });
+
+    juce::Path valueTrack;
+    const auto maxPoint = [&]
+    {
+        auto kx = horizontal ? sliderPos : ((float) x + (float) width * 0.5f);
+        auto ky = horizontal ? ((float) y + (float) height * 0.5f) : sliderPos;
+        return juce::Point { kx, ky };
+    }();
+    const auto modPoint = [&]
+    {
+        auto kmx = horizontal ? modSliderPos : ((float) x + (float) width * 0.5f);
+        auto kmy = horizontal ? ((float) y + (float) height * 0.5f) : modSliderPos;
+        return juce::Point { kmx, kmy };
+    }();
+
+    valueTrack.startNewSubPath (startPoint);
+    valueTrack.lineTo (modPoint);
+    g.setColour (Colour (0xff9cbcbd).withAlpha (alphaMult));
+    g.strokePath (valueTrack, { trackWidth, juce::PathStrokeType::curved, juce::PathStrokeType::rounded });
+
+    auto thumbWidth = getLookAndFeel().getSliderThumbRadius (*this);
+    auto thumbRect = juce::Rectangle<float> (static_cast<float> (thumbWidth),
+                                             static_cast<float> (thumbWidth))
+            .withCentre (maxPoint);
+    sharedAssets->knob->drawWithin (g, thumbRect, juce::RectanglePlacement::stretchToFit, alphaMult);
+}
+
+void ModulatableSlider::paint (Graphics& g)
+{
+    if (modParameter == nullptr)
+        return;
+
+    auto& lf = getLookAndFeel();
+    auto layout = lf.getSliderLayout (*this);
+    const auto sliderRect = layout.sliderBounds;
+
+    modulatedValue = modParameter->getCurrentValue();
+    if (isRotary())
+    {
+        const auto sliderPos = (float) valueToProportionOfLength (getValue());
+        const auto modSliderPos = (float) jlimit (0.0, 1.0, valueToProportionOfLength (modulatedValue));
+        drawRotarySlider (g,
+                          sliderRect.getX(),
+                          sliderRect.getY(),
+                          sliderRect.getWidth(),
+                          sliderRect.getHeight(),
+                          sliderPos,
+                          modSliderPos);
+    }
+    else
+    {
+        const auto normRange = NormalisableRange { getRange() };
+        const auto sliderPos = getPositionOfValue (getValue());
+        const auto modSliderPos = getPositionOfValue (modulatedValue);
+        drawLinearSlider (g,
+                          sliderRect.getX(),
+                          sliderRect.getY(),
+                          sliderRect.getWidth(),
+                          sliderRect.getHeight(),
+                          sliderPos,
+                          modSliderPos);
+    }
+}
+
 //====================================================================
 ModSliderItem::ModSliderItem (foleys::MagicGUIBuilder& builder, const juce::ValueTree& node) : GuiItem (builder, node)
 {
diff --git a/Plugin/Source/GUI/ModulatableSlider.h b/Plugin/Source/GUI/ModulatableSlider.h
@@ -8,6 +8,7 @@ class ModulatableSlider : public foleys::AutoOrientationSlider,
 public:
     ModulatableSlider() = default;
 
+    void paint (Graphics& g) override;
     void attachToParameter (juce::RangedAudioParameter* param);
     double getModulatedPosition();
 
@@ -19,6 +20,8 @@ public:
 
 private:
     void timerCallback() override;
+    void drawRotarySlider (juce::Graphics& g, int x, int y, int width, int height, float sliderPos, float modSliderPos);
+    void drawLinearSlider (juce::Graphics& g, int x, int y, int width, int height, float sliderPos, float modSliderPos);
 
     std::unique_ptr<juce::SliderParameterAttachment> attachment;
     chowdsp::FloatParameter* modParameter = nullptr;
@@ -26,6 +29,13 @@ private:
 
     double modulatedValue = 0.0;
 
+    struct KnobAssets
+    {
+        std::unique_ptr<Drawable> knob = Drawable::createFromImageData (chowdsp_BinaryData::knob_svg, chowdsp_BinaryData::knob_svgSize);
+        std::unique_ptr<Drawable> pointer = Drawable::createFromImageData (chowdsp_BinaryData::pointer_svg, chowdsp_BinaryData::pointer_svgSize);
+    };
+    SharedResourcePointer<KnobAssets> sharedAssets;
+
     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (ModulatableSlider)
 };
 
@@ -52,7 +62,7 @@ public:
     void update() override;
     void resized() override;
 
-    std::vector<foleys::SettableProperty> getSettableProperties() const override;
+    [[nodiscard]] std::vector<foleys::SettableProperty> getSettableProperties() const override;
     juce::String getControlledParameterID (juce::Point<int>) override;
     juce::Component* getWrappedComponent() override;