init

Source/PluginEditor.h

@@ -21,13 +21,115 @@ public:
                       juce::ComboBox&) override;
     void positionComboBoxText(juce::ComboBox&, juce::Label&) override;
 
-    juce::Colour cyan   { 0xff00e5ff };
-    juce::Colour magenta{ 0xffff2fd6 };
-    juce::Colour violet { 0xff8a2be2 };
-    juce::Colour bg     { 0xff0b0f16 };
-    juce::Colour panel  { 0xff121a24 };
-    juce::Colour line   { 0xff1f2a38 };
-    juce::Colour textDim{ 0xff7a8aa0 };
+    juce::Colour cyan()    const { return transform(baseCyan); }
+    juce::Colour magenta() const { return transform(baseMagenta); }
+    juce::Colour violet()  const { return transform(baseViolet); }
+    juce::Colour bg()      const { return transform(baseBg); }
+    juce::Colour panel()   const { return transform(basePanel); }
+    juce::Colour line()    const { return transform(baseLine); }
+    juce::Colour textDim() const { return transform(baseTextDim); }
+
+    void refreshPalette();
+
+    float hueShift = 0.0f;
+    float saturation = 1.0f;
+    float brightness = 1.0f;
+    float waveformOpacity = 0.2f;
+    float waveSensitivity = 0.0f; // in dB, added to the spectrum display level
+    float uiScale = 1.0f;
+
+private:
+    juce::Colour transform(juce::Colour c) const
+    {
+        return c.withRotatedHue(hueShift)
+                .withMultipliedSaturation(saturation)
+                .withMultipliedBrightness(brightness);
+    }
+
+    const juce::Colour baseCyan   { 0xff00e5ff };
+    const juce::Colour baseMagenta{ 0xffff2fd6 };
+    const juce::Colour baseViolet { 0xff8a2be2 };
+    const juce::Colour baseBg     { 0xff0b0f16 };
+    const juce::Colour basePanel  { 0xff121a24 };
+    const juce::Colour baseLine   { 0xff1f2a38 };
+    const juce::Colour baseTextDim{ 0xff7a8aa0 };
+};
+
+// ---------------------------------------------------------------------------
+
+// Log-frequency horizontal mapping shared by the band columns and the EQ curve,
+// so a band's position in the visualizer always lines up with the curve peak at
+// the same frequency. 20 Hz sits at the left edge, 20 kHz at the right.
+inline float bandLogNorm(float freq)
+{
+    return (std::log10(freq) - std::log10(20.0f)) / (std::log10(20000.0f) - std::log10(20.0f));
+}
+inline float bandFreqToX(float freq, float x0, float width)
+{
+    return x0 + bandLogNorm(freq) * width;
+}
+inline float bandXToFreq(float x, float x0, float width)
+{
+    const float norm = (width > 0.0f) ? (x - x0) / width : 0.0f;
+    return std::pow(10.0f, std::log10(20.0f) + norm * (std::log10(20000.0f) - std::log10(20.0f)));
+}
+
+// The large fader of each band. Dragging vertically changes the level, dragging
+// horizontally changes the band's frequency, and scrolling the mouse wheel
+// nudges the band's Q. All three write straight to the plugin's parameters.
+class BandFader final : public juce::Component
+{
+public:
+    BandFader(juce::AudioProcessorValueTreeState& apvts,
+              const juce::String& gainId, const juce::String& freqId,
+              const juce::String& qId, NeonLookAndFeel& lnf)
+        : gainP(dynamic_cast<juce::AudioParameterFloat*>(apvts.getParameter(gainId))),
+          freqP(dynamic_cast<juce::AudioParameterFloat*>(apvts.getParameter(freqId))),
+          qP(dynamic_cast<juce::AudioParameterFloat*>(apvts.getParameter(qId))),
+          lf(lnf)
+    {
+        setRepaintsOnMouseActivity(false);
+    }
+
+    void paint(juce::Graphics&) override;
+    void mouseDown(const juce::MouseEvent&) override;
+    void mouseDrag(const juce::MouseEvent&) override;
+    void mouseUp(const juce::MouseEvent&) override;
+    void mouseEnter(const juce::MouseEvent&) override;
+    void mouseExit(const juce::MouseEvent&) override;
+    void mouseWheelMove(const juce::MouseEvent&, const juce::MouseWheelDetails&) override;
+
+    float getGain() const { return gainP != nullptr ? (float) gainP->get() : 0.0f; }
+
+    // The x-origin and width of the full visualizer area, used so a horizontal
+    // drag moves the fader 1:1 with the mouse cursor.
+    void setDragSpace(float x0, float width)
+    {
+        dragX0 = x0;
+        dragWidth = width;
+    }
+
+    // Ask the containing editor to redispose the columns after a frequency drag.
+    std::function<void()> onFreqChange;
+
+    // Returns the ordering bounds [minFreq, maxFreq] this band's frequency is
+    // allowed to take, so bands keep their left-to-right order.
+    std::function<std::pair<float, float>()> onGetFreqBounds;
+
+private:
+    juce::AudioParameterFloat* gainP;
+    juce::AudioParameterFloat* freqP;
+    juce::AudioParameterFloat* qP;
+    NeonLookAndFeel& lf;
+
+    bool dragging = false;
+    bool hovered = false;
+    float startGain = 0.0f;
+    float startFreq = 1000.0f;
+    int startX = 0;
+    int startY = 0;
+    float dragX0 = 0.0f;
+    float dragWidth = 1.0f;
 };
 
 // ---------------------------------------------------------------------------
@@ -46,6 +148,10 @@ public:
 private:
     void rebuildFaders();
     void scaleUI(float percent);
+    void refreshColors();
+    void refreshFonts(float s);
+    void updateGainValue(int i);
+    void updateMasterPercent();
 
     GelykEQAudioProcessor& processor;
 
@@ -54,12 +160,15 @@ private:
     static constexpr int numBands = 7;
     struct BandWidget
     {
-        std::unique_ptr<juce::Slider> gain;
+        std::unique_ptr<BandFader> gain;
+        std::unique_ptr<juce::Slider> level;
         std::unique_ptr<juce::Slider> q;
         std::unique_ptr<juce::Slider> freq;
         std::unique_ptr<juce::Label> freqLabel;
         std::unique_ptr<juce::Label> gainCaption;
         std::unique_ptr<juce::Label> gainValue;
+        std::unique_ptr<juce::Label> levelCaption;
+        std::unique_ptr<juce::Label> levelValue;
         std::unique_ptr<juce::Label> qCaption;
         std::unique_ptr<juce::Label> qValue;
         std::unique_ptr<juce::Label> freqCaption;
@@ -68,6 +177,7 @@ private:
     BandWidget bands[numBands];
 
     std::unique_ptr<juce::Label> masterLabel;
+    std::unique_ptr<juce::Label> masterPercent;
     std::unique_ptr<juce::Slider> master;
 
     std::unique_ptr<juce::ComboBox> scaleBox;
@@ -76,7 +186,19 @@ private:
     std::unique_ptr<juce::Label> statusBar;
     std::unique_ptr<juce::Label> statusGit;
 
-    std::unique_ptr<juce::AudioProcessorValueTreeState::SliderAttachment> gainAttachments[numBands];
+    std::unique_ptr<juce::Label> colorHueLabel;
+    std::unique_ptr<juce::Label> colorSatLabel;
+    std::unique_ptr<juce::Label> colorBriLabel;
+    std::unique_ptr<juce::Label> waveLabel;
+    std::unique_ptr<juce::Label> waveSensLabel;
+
+    std::unique_ptr<juce::Slider> colorHueSlider;
+    std::unique_ptr<juce::Slider> colorSatSlider;
+    std::unique_ptr<juce::Slider> colorBriSlider;
+    std::unique_ptr<juce::Slider> waveSlider;
+    std::unique_ptr<juce::Slider> waveSensSlider;
+
+    std::unique_ptr<juce::AudioProcessorValueTreeState::SliderAttachment> levelAttachments[numBands];
     std::unique_ptr<juce::AudioProcessorValueTreeState::SliderAttachment> qAttachments[numBands];
     std::unique_ptr<juce::AudioProcessorValueTreeState::SliderAttachment> freqAttachments[numBands];
     std::unique_ptr<juce::AudioProcessorValueTreeState::SliderAttachment> masterAttachment;
@@ -84,6 +206,7 @@ private:
     juce::Array<float> spectrum;
     juce::Array<float> freqBins;
     juce::Array<float> eqCurve;
+    juce::Rectangle<float> bandSections[numBands]; // knob-group outlines
     std::atomic<float> scaling { 1.0f }; // for resized()
 
     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(GelykEQAudioProcessorEditor)