chorus_section.cpp

Go to the documentation of this file.

 
 
#include "chorus_section.h"
 
#include "chorus_module.h"
#include "delay_section.h"
#include "skin.h"
#include "fonts.h"
#include "synth_strings.h"
#include "synth_button.h"
#include "synth_slider.h"
#include "tempo_selector.h"
#include "text_look_and_feel.h"
 
class ChorusViewer : public BarRenderer {
public:
    static constexpr int kDelays = vital::ChorusModule::kMaxDelayPairs;
    static constexpr int kNumBars = kDelays * vital::poly_float::kSize;
 
    ChorusViewer() : BarRenderer(kNumBars, true), delays_() {
        active_ = true;
        parent_ = nullptr;
        num_voices_ = nullptr;
 
        setBarWidth(0.3f);
        setScale(1.0f);
        setAdditiveBlending(true);
    }
 
    void parentHierarchyChanged() override {
        if (delays_[0])
            return;
 
        SynthGuiInterface* parent = findParentComponentOfClass<SynthGuiInterface>();
        if (parent == nullptr)
            return;
 
        for (int i = 0; i < kDelays; ++i)
            delays_[i] = parent->getSynth()->getStatusOutput("chorus_delays" + std::to_string(i + 1));
    }
 
    void drawBars(OpenGlWrapper& open_gl, bool animate) {
        static constexpr float kMaxDelay = 0.07f;
        static constexpr float kMinDelay = 0.000f;
        static constexpr float kDelayRange = kMaxDelay - kMinDelay;
 
        if (delays_[0] == nullptr)
            return;
 
        int num_voices = static_cast<int>(num_voices_->getValue() * vital::poly_float::kSize);
        for (int i = 0; i < num_voices; ++i) {
            vital::poly_float delay_frequency = delays_[i / vital::poly_float::kSize]->value();
            float delay = 1.0f / delay_frequency[i % vital::poly_float::kSize];
            setX(i, 2.0f * (delay - kMinDelay) / kDelayRange - 1.0f);
            setY(i, 0.5f);
            setBottom(i, -0.5f);
        }
 
        for (int i = num_voices; i < num_points_; ++i)
            setX(i , -2.0f);
 
        BarRenderer::render(open_gl, animate);
    }
 
    void render(OpenGlWrapper& open_gl, bool animate) override {
        if (active_) {
            Colour color = findColour(Skin::kWidgetSecondary1, true);
            float alpha = color.getFloatAlpha();
            setColor(color.withAlpha(alpha + (1.0f - alpha) * alpha));
        }
        else
            setColor(findColour(Skin::kWidgetSecondaryDisabled, true));
 
        drawBars(open_gl, animate);
        renderCorners(open_gl, animate);
    }
 
    void setActive(bool active) { active_ = active; }
 
    void setNumVoicesSlider(SynthSlider* num_voices) { num_voices_ = num_voices; }
 
private:
    bool active_;                            
    const vital::StatusOutput* delays_[4];    
    SynthSlider* num_voices_;                 
 
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(ChorusViewer)
};
 
ChorusSection::ChorusSection(const String& name, const vital::output_map& mono_modulations) : SynthSection(name) {
  static const double kTempoDragSensitivity = 0.5;
  static constexpr int kViewerResolution = 64;
 
  voices_ = std::make_unique<SynthSlider>("chorus_voices");
  addSlider(voices_.get());
  voices_->setSliderStyle(Slider::RotaryHorizontalVerticalDrag);
  voices_->setLookAndFeel(TextLookAndFeel::instance());
  voices_->setSensitivity(kTempoDragSensitivity);
 
  delay_1_ = std::make_unique<SynthSlider>("chorus_delay_1");
  addSlider(delay_1_.get());
  delay_1_->setSliderStyle(Slider::RotaryHorizontalVerticalDrag);
 
  delay_2_ = std::make_unique<SynthSlider>("chorus_delay_2");
  addSlider(delay_2_.get());
  delay_2_->setSliderStyle(Slider::RotaryHorizontalVerticalDrag);
 
  mod_depth_ = std::make_unique<SynthSlider>("chorus_mod_depth");
  addSlider(mod_depth_.get());
  mod_depth_->setSliderStyle(Slider::RotaryHorizontalVerticalDrag);
 
  frequency_ = std::make_unique<SynthSlider>("chorus_frequency");
  addSlider(frequency_.get());
  frequency_->setSliderStyle(Slider::RotaryHorizontalVerticalDrag);
  frequency_->setLookAndFeel(TextLookAndFeel::instance());
 
  tempo_ = std::make_unique<SynthSlider>("chorus_tempo");
  addSlider(tempo_.get());
  tempo_->setSliderStyle(Slider::RotaryHorizontalVerticalDrag);
  tempo_->setLookAndFeel(TextLookAndFeel::instance());
  tempo_->setSensitivity(kTempoDragSensitivity);
 
  sync_ = std::make_unique<TempoSelector>("chorus_sync");
  addSlider(sync_.get());
  sync_->setSliderStyle(Slider::LinearBar);
  sync_->setTempoSlider(tempo_.get());
  sync_->setFreeSlider(frequency_.get());
 
  feedback_ = std::make_unique<SynthSlider>("chorus_feedback");
  addSlider(feedback_.get());
  feedback_->setSliderStyle(Slider::RotaryHorizontalVerticalDrag);
  feedback_->setBipolar();
  feedback_->snapToValue(true);
 
  dry_wet_ = std::make_unique<SynthSlider>("chorus_dry_wet");
  addSlider(dry_wet_.get());
  dry_wet_->setSliderStyle(Slider::RotaryHorizontalVerticalDrag);
 
  filter_cutoff_ = std::make_unique<SynthSlider>("chorus_cutoff");
  addSlider(filter_cutoff_.get());
  filter_cutoff_->setSliderStyle(Slider::RotaryHorizontalVerticalDrag);
 
  filter_spread_ = std::make_unique<SynthSlider>("chorus_spread");
  addSlider(filter_spread_.get());
  filter_spread_->setSliderStyle(Slider::RotaryHorizontalVerticalDrag);
 
  chorus_viewer_ = std::make_unique<ChorusViewer>();
  addOpenGlComponent(chorus_viewer_.get());
  chorus_viewer_->setNumVoicesSlider(voices_.get());
 
  filter_viewer_ = std::make_unique<DelayFilterViewer>("chorus", kViewerResolution, mono_modulations);
  filter_viewer_->setCutoffSlider(filter_cutoff_.get());
  filter_viewer_->setSpreadSlider(filter_spread_.get());
  filter_viewer_->addListener(this);
  addOpenGlComponent(filter_viewer_.get());
 
  on_ = std::make_unique<SynthButton>("chorus_on");
  addButton(on_.get());
  setActivator(on_.get());
  setSkinOverride(Skin::kChorus);
}
 
ChorusSection::~ChorusSection() = default;
 
void ChorusSection::paintBackground(Graphics& g) {
  SynthSection::paintBackground(g);
 
  Rectangle<int> frequency_bounds(tempo_->getX(), tempo_->getY(),
                                  sync_->getRight() - tempo_->getX(), tempo_->getHeight());
  drawTextComponentBackground(g, frequency_bounds, true);
  drawTextComponentBackground(g, voices_->getBounds(), true);
 
  setLabelFont(g);
  drawLabel(g, TRANS("FREQUENCY"), frequency_bounds, true);
  drawLabelForComponent(g, TRANS("VOICES"), voices_.get(), true);
  drawLabelForComponent(g, TRANS("FEEDBACK"), feedback_.get());
  drawLabelForComponent(g, TRANS("MIX"), dry_wet_.get());
  drawLabelForComponent(g, TRANS("DEPTH"), mod_depth_.get());
  drawLabelForComponent(g, TRANS("DELAY 1"), delay_1_.get());
  drawLabelForComponent(g, TRANS("DELAY 2"), delay_2_.get());
  drawLabelForComponent(g, TRANS("CUTOFF"), filter_cutoff_.get());
  drawLabelForComponent(g, TRANS("SPREAD"), filter_spread_.get());
 
  drawTempoDivider(g, sync_.get());
}
 
void ChorusSection::resized() {
  int widget_margin = findValue(Skin::kWidgetMargin);
  int title_width = getTitleWidth();
  int section_height = getKnobSectionHeight();
 
  Rectangle<int> bounds = getLocalBounds().withLeft(title_width);
  Rectangle<int> delay_area = getDividedAreaBuffered(bounds, 3, 0, widget_margin);
  Rectangle<int> knobs_area = getDividedAreaBuffered(bounds, 3, 2, widget_margin);
 
  placeKnobsInArea(Rectangle<int>(delay_area.getX(), 0, delay_area.getWidth(), section_height),
                   { voices_.get(), tempo_.get()});
  voices_->setBounds(voices_->getBounds().withTop(widget_margin));
  placeTempoControls(tempo_->getX(), widget_margin, tempo_->getWidth(),
                     section_height - 2 * widget_margin, frequency_.get(), sync_.get());
  tempo_->setBounds(frequency_->getBounds());
  tempo_->setModulationArea(frequency_->getModulationArea());
 
  int delay_y = section_height - widget_margin;
  placeKnobsInArea(Rectangle<int>(delay_area.getX(), delay_y, delay_area.getWidth(), section_height),
                   { mod_depth_.get(), delay_1_.get(), delay_2_.get() });
 
  int widget_x = delay_2_->getRight() + widget_margin;
  int viewer_width = knobs_area.getX() - widget_x;
  int delay_height = (getHeight() - 3 * widget_margin) / 2;
  int filter_y = delay_height + 2 * widget_margin;
  chorus_viewer_->setBounds(widget_x, widget_margin, viewer_width, delay_height);
  filter_viewer_->setBounds(widget_x, filter_y, viewer_width, getHeight() - filter_y - widget_margin);
 
  placeKnobsInArea(Rectangle<int>(knobs_area.getX(), 0, knobs_area.getWidth(), section_height),
                   { feedback_.get(),  dry_wet_.get() });
 
  int knob_y2 = section_height - widget_margin;
  placeKnobsInArea(Rectangle<int>(knobs_area.getX(), knob_y2, knobs_area.getWidth(), section_height),
                   { filter_cutoff_.get(), filter_spread_.get() });
 
  SynthSection::resized();
}
 
void ChorusSection::setActive(bool active) {
  SynthSection::setActive(active);
  chorus_viewer_->setActive(active);
  filter_viewer_->setActive(active);
}
 
void ChorusSection::deltaMovement(float x, float y) {
  double x_range = filter_cutoff_->getMaximum() - filter_cutoff_->getMinimum();
  double y_range = filter_spread_->getMaximum() - filter_spread_->getMinimum();
 
  filter_cutoff_->setValue(filter_cutoff_->getValue() + x * x_range);
  filter_spread_->setValue(filter_spread_->getValue() + y * y_range);
}