envelope_editor.h

Go to the documentation of this file.

#pragma once
 
#include "JuceHeader.h"
#include "skin.h"
#include "open_gl_image.h"
#include "open_gl_line_renderer.h"
#include "synth_module.h"
#include "synth_slider.h"
 
class EnvelopeEditor : public OpenGlLineRenderer, public SynthSlider::SliderListener {
public:
    static constexpr float kMarkerWidth = 9.0f;
    static constexpr float kRingThickness = 0.45f;
    static constexpr float kPowerMarkerWidth = 7.0f;
    static constexpr float kMarkerHoverRadius = 12.0f;
    static constexpr float kMarkerGrabRadius = 20.0f;
    static constexpr float kTailDecay = 0.965f;
    static constexpr float kPaddingX = 0.018f;
    static constexpr float kPaddingY = 0.06f;
    static constexpr float kMinPointDistanceForPower = 3.0f;
    static constexpr float kPowerMouseMultiplier = 0.06f;
    static constexpr float kTimeDisplaySize = 0.05f;
 
    static constexpr int kRulerDivisionSize = 4;
    static constexpr int kMaxGridLines = 36;
    static constexpr int kMaxTimesShown = 24;
    static constexpr int kNumPointsPerSection = 98;
    static constexpr int kNumSections = 4;
    static constexpr int kTotalPoints = kNumSections * kNumPointsPerSection + 1;
 
    EnvelopeEditor(const String& prefix,
                   const vital::output_map& mono_modulations, const vital::output_map& poly_modulations);
 
    ~EnvelopeEditor();
 
    void paintBackground(Graphics& g) override;
 
    void resized() override {
        OpenGlLineRenderer::resized();
        drag_circle_.setBounds(getLocalBounds());
        hover_circle_.setBounds(getLocalBounds());
        grid_lines_.setBounds(getLocalBounds());
        sub_grid_lines_.setBounds(getLocalBounds());
        position_circle_.setBounds(getLocalBounds());
        point_circles_.setBounds(getLocalBounds());
        power_circles_.setBounds(getLocalBounds());
 
        float font_height = kTimeDisplaySize * getHeight();
        for (int i = 0; i < kMaxTimesShown; ++i)
            times_[i]->setTextSize(font_height);
 
        setTimePositions();
        reset_positions_ = true;
    }
 
    void resetEnvelopeLine(int index);
 
    void guiChanged(SynthSlider* slider) override;
 
    void setDelaySlider(SynthSlider* delay_slider);
    void setAttackSlider(SynthSlider* attack_slider);
    void setAttackPowerSlider(SynthSlider* attack_slider);
    void setHoldSlider(SynthSlider* hold_slider);
    void setDecaySlider(SynthSlider* decay_slider);
    void setDecayPowerSlider(SynthSlider* decay_slider);
    void setSustainSlider(SynthSlider* sustain_slider);
    void setReleaseSlider(SynthSlider* release_slider);
    void setReleasePowerSlider(SynthSlider* release_slider);
 
    void setSizeRatio(float ratio) { size_ratio_ = ratio; }
 
    void parentHierarchyChanged() override;
 
    void pickHoverPosition(Point<float> position);
 
    void mouseMove(const MouseEvent& e) override;
    void mouseExit(const MouseEvent& e) override;
    void mouseDown(const MouseEvent& e) override;
    void mouseDrag(const MouseEvent& e) override;
    void mouseDoubleClick(const MouseEvent& e) override;
    void mouseUp(const MouseEvent& e) override;
 
    void mouseWheelMove(const MouseEvent& e, const MouseWheelDetails& wheel) override;
 
    void magnifyZoom(Point<float> delta);
 
    void magnifyReset();
 
    void init(OpenGlWrapper& open_gl) override;
 
    void render(OpenGlWrapper& open_gl, bool animate) override;
 
    void destroy(OpenGlWrapper& open_gl) override;
 
    void resetPositions() { reset_positions_ = true; }
 
  private:
    void setEditingCircleBounds();
 
    void setGridPositions();
 
    void setTimePositions();
 
    void setPointPositions();
 
    void setGlPositions();
 
    void setColors();
 
    void zoom(float amount);
 
    static std::pair<vital::Output*, vital::Output*> getOutputs(const vital::output_map& mono_modulations,
                                                                const vital::output_map& poly_modulations,
                                                                const String& name) {
      return {
        mono_modulations.at(name.toStdString()),
        poly_modulations.at(name.toStdString())
      };
    }
 
    vital::poly_float getOutputsTotal(std::pair<vital::Output*, vital::Output*> outputs,
                                      vital::poly_float default_value);
 
    void drawPosition(OpenGlWrapper& open_gl, int index);
 
    std::pair<float, float> getPosition(int index);
 
    // Utility functions for coordinate padding and unpadding.
    float padX(float x);
    float padY(float y);
    float unpadX(float x);
    float unpadY(float y);
    float padOpenGlX(float x);
    float padOpenGlY(float y);
 
    // Slider-specific getter methods for times and positions.
    float getSliderDelayX();
    float getSliderAttackX();
    float getSliderHoldX();
    float getSliderDecayX();
    float getSliderSustainY();
    float getSliderReleaseX();
    float getDelayTime(int index);
    float getAttackTime(int index);
    float getHoldTime(int index);
    float getDecayTime(int index);
    float getReleaseTime(int index);
    float getDelayX(int index);
    float getAttackX(int index);
    float getHoldX(int index);
    float getDecayX(int index);
    float getSustainY(int index);
    float getReleaseX(int index);
 
    float getBackupPhase(float phase, int index);
    vital::poly_float getBackupPhase(vital::poly_float phase);
    float getEnvelopeValue(float t, float power, float start, float end);
    float getSliderAttackValue(float t);
    float getSliderDecayValue(float t);
    float getSliderReleaseValue(float t);
    float getAttackValue(float t, int index);
    float getDecayValue(float t, int index);
    float getReleaseValue(float t, int index);
 
    // Setters for envelope parameters based on mouse interactions.
    void setDelayX(float x);
    void setAttackX(float x);
    void setHoldX(float x);
    void setDecayX(float x);
    void setSustainY(float y);
    void setReleaseX(float x);
 
    void setPower(SynthSlider* slider, float power);
    void setAttackPower(float power);
    void setDecayPower(float power);
    void setReleasePower(float power);
 
    SynthGuiInterface* parent_;
    bool delay_hover_;
    bool attack_hover_;
    bool hold_hover_;
    bool sustain_hover_;
    bool release_hover_;
    bool attack_power_hover_;
    bool decay_power_hover_;
    bool release_power_hover_;
    bool mouse_down_;
    Point<float> last_edit_position_;
 
    bool animate_;
    float size_ratio_;
    float window_time_;
 
    vital::poly_float current_position_alpha_;
    vital::poly_float last_phase_;
 
    Colour line_left_color_;
    Colour line_right_color_;
    Colour line_center_color_;
    Colour fill_left_color_;
    Colour fill_right_color_;
    Colour background_color_;
    Colour time_color_;
 
    bool reset_positions_;
    OpenGlQuad drag_circle_;
    OpenGlQuad hover_circle_;
    OpenGlMultiQuad grid_lines_;
    OpenGlMultiQuad sub_grid_lines_;
    OpenGlQuad position_circle_;
    OpenGlMultiQuad point_circles_;
    OpenGlMultiQuad power_circles_;
    std::unique_ptr<PlainTextComponent> times_[kMaxTimesShown];
 
    const vital::StatusOutput* envelope_phase_;
 
    SynthSlider* delay_slider_;
    SynthSlider* attack_slider_;
    SynthSlider* hold_slider_;
    SynthSlider* attack_power_slider_;
    SynthSlider* decay_slider_;
    SynthSlider* decay_power_slider_;
    SynthSlider* sustain_slider_;
    SynthSlider* release_slider_;
    SynthSlider* release_power_slider_;
 
    std::pair<vital::Output*, vital::Output*> delay_outputs_;
    std::pair<vital::Output*, vital::Output*> attack_outputs_;
    std::pair<vital::Output*, vital::Output*> hold_outputs_;
    std::pair<vital::Output*, vital::Output*> decay_outputs_;
    std::pair<vital::Output*, vital::Output*> sustain_outputs_;
    std::pair<vital::Output*, vital::Output*> release_outputs_;
 
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(EnvelopeEditor)
};