wavetable_3d.h

Go to the documentation of this file.

 
 
#pragma once
 
#include "JuceHeader.h"
#include "open_gl_line_renderer.h"
#include "audio_file_drop_source.h"
#include "common.h"
#include "open_gl_image.h"
#include "synth_oscillator.h"
#include "synth_types.h"
#include "wavetable.h"
#include "wavetable_creator.h"
 
namespace vital {
    struct Output;
    class Wavetable;
}
 
class Wavetable3d : public OpenGlComponent, public AudioFileDropSource {
public:
    static constexpr float kDefaultVerticalAngle = 1.132f;
    static constexpr float kDefaultHorizontalAngle = -0.28f;
    static constexpr float kDefaultDrawWidthPercent = 0.728f;
    static constexpr float kDefaultWaveHeightPercent = 0.083f;
    static constexpr float kPositionWidth = 8.0f;
    static constexpr float kPositionLineWidthRatio = 1.8f;
    static constexpr int kColorJump = 16;
    static constexpr int kDownsampleResolutionAmount = 0;
    static constexpr int kResolution = vital::Wavetable::kWaveformSize >> kDownsampleResolutionAmount;
    static constexpr int kNumBits = vital::WaveFrame::kWaveformBits;
    static constexpr int kBackgroundResolution = 128;
    static constexpr int kExtraShadows = 20;
    static constexpr float k2dWaveHeightPercent = 0.25f;
 
    static void paint3dLine(Graphics& g, vital::Wavetable* wavetable, int index, Colour color,
                            float width, float height, float wave_height_percent,
                            float wave_range_x, float frame_range_x, float wave_range_y, float frame_range_y,
                            float start_x, float start_y, float offset_x, float offset_y);
 
    static void paint3dBackground(Graphics& g, vital::Wavetable* wavetable, bool active,
                                  Colour background_color, Colour wave_color1, Colour wave_color2,
                                  float width, float height,
                                  float wave_height_percent,
                                  float wave_range_x, float frame_range_x, float wave_range_y, float frame_range_y,
                                  float start_x, float start_y, float offset_x, float offset_y);
 
    enum MenuOptions {
        kCancel,
        kCopy,
        kPaste,
        kInit,
        kSave,
        kTextToWavetable,
        kResynthesizePreset,
        kLogIn,
        kNumMenuOptions
    };
 
    enum RenderType {
        kWave3d,
        kWave2d,
        kFrequencyAmplitudes,
        kNumRenderTypes
    };
 
    class Listener {
    public:
        virtual ~Listener() { }
 
        virtual bool loadAudioAsWavetable(String name, InputStream* audio_stream,
                                          WavetableCreator::AudioFileLoadStyle style) = 0;
 
        virtual void loadWavetable(json& wavetable_data) = 0;
 
        virtual void loadDefaultWavetable() = 0;
 
        virtual void resynthesizeToWavetable() = 0;
 
        virtual void textToWavetable() = 0;
 
        virtual void saveWavetable() = 0;
    };
 
    Wavetable3d(int index, const vital::output_map& mono_modulations, const vital::output_map& poly_modulations);
 
    virtual ~Wavetable3d();
 
    void init(OpenGlWrapper& open_gl) override;
 
    void render(OpenGlWrapper& open_gl, bool animate) override;
 
    void renderWave(OpenGlWrapper& open_gl);
 
    void renderSpectrum(OpenGlWrapper& open_gl);
 
    void destroy(OpenGlWrapper& open_gl) override;
 
    void paintBackground(Graphics& g) override;
 
    void resized() override;
 
    void mouseDown(const MouseEvent& e) override;
 
    void mouseDrag(const MouseEvent& e) override;
 
    void mouseExit(const MouseEvent& e) override;
 
    void mouseWheelMove(const MouseEvent& e, const MouseWheelDetails& wheel) override;
 
    void setFrameSlider(SynthSlider* slider) { frame_slider_ = slider; }
 
    void setSpectralMorphSlider(Slider* slider) { spectral_morph_slider_ = slider; }
 
    void setDistortionSlider(Slider* slider) { distortion_slider_ = slider; }
 
    void setDistortionPhaseSlider(Slider* slider) { distortion_phase_slider_ = slider; }
 
    void setViewSettings(float horizontal_angle, float vertical_angle,
                         float draw_width, float wave_height, float y_offset);
 
    void setRenderType(RenderType render_type);
 
    RenderType getRenderType() const { return render_type_; }
 
    void setSpectralMorphType(int spectral_morph_type) { spectral_morph_type_ = spectral_morph_type; }
 
    void setDistortionType(int distortion_type) { distortion_type_ = distortion_type; }
 
    void respondToMenuCallback(int option);
 
    bool hasMatchingSystemClipboard();
 
    void setActive(bool active) { active_ = active; }
 
    bool isActive() { return active_; }
 
    void audioFileLoaded(const File& file) override;
 
    void updateDraggingPosition(int x, int y);
 
    void fileDragEnter(const StringArray& files, int x, int y) override {
        updateDraggingPosition(x, y);
    }
 
    void fileDragMove(const StringArray& files, int x, int y) override {
        updateDraggingPosition(x, y);
    }
 
    void fileDragExit(const StringArray& files) override {
        drag_load_style_ = WavetableCreator::kNone;
    }
 
    void addListener(Listener* listener) { listeners_.push_back(listener); }
 
    void setLoadingWavetable(bool loading) { loading_wavetable_ = loading; }
 
    void setDirty() { last_spectral_morph_type_ = -1; }
 
    vital::Wavetable* getWavetable() { return wavetable_; }
 
private:
    bool updateRenderValues();
 
    void loadIntoTimeDomain(int index);
 
    void loadWaveData(int index);
 
    void loadSpectrumData(int index);
 
    void drawPosition(OpenGlWrapper& open_gl, int index);
 
    void setDimensionValues();
 
    void setColors();
 
    vital::poly_float getDistortionValue();
 
    vital::poly_float getSpectralMorphValue();
 
    vital::poly_int getDistortionPhaseValue();
 
    void loadFrequencyData(int index);
 
    void warpSpectrumToWave(int index);
 
    void warpPhase(int index);
 
    inline vital::poly_float getOutputsTotal(std::pair<vital::Output*, vital::Output*> outputs,
                                             vital::poly_float default_value);
 
    OpenGlLineRenderer left_line_renderer_;   
    OpenGlLineRenderer right_line_renderer_;  
    OpenGlMultiQuad end_caps_;                
 
    Colour import_text_color_;
    OpenGlQuad import_overlay_;              
    std::unique_ptr<PlainTextComponent> wavetable_import_text_;
    std::unique_ptr<PlainTextComponent> vocode_import_text_;
    std::unique_ptr<PlainTextComponent> pitch_splice_import_text_;
 
    Colour body_color_;
    Colour line_left_color_;
    Colour line_right_color_;
    Colour line_disabled_color_;
    Colour fill_left_color_;
    Colour fill_right_color_;
    Colour fill_disabled_color_;
 
    std::vector<Listener*> listeners_;                      
    std::pair<vital::Output*, vital::Output*> wave_frame_outputs_;
    std::pair<vital::Output*, vital::Output*> spectral_morph_outputs_;
    std::pair<vital::Output*, vital::Output*> distortion_outputs_;
    std::pair<vital::Output*, vital::Output*> distortion_phase_outputs_;
 
    int last_spectral_morph_type_;
    int last_distortion_type_;
    int spectral_morph_type_;
    int distortion_type_;
    vital::poly_float wave_frame_;
    vital::poly_float spectral_morph_value_;
    vital::poly_float distortion_value_;
    vital::poly_int distortion_phase_;
 
    SynthSlider* frame_slider_;
    Slider* spectral_morph_slider_;
    Slider* distortion_slider_;
    Slider* distortion_phase_slider_;
    Point<int> last_edit_position_;
    WavetableCreator::AudioFileLoadStyle drag_load_style_;
    vital::WaveFrame process_frame_;
    vital::FourierTransform transform_;
    vital::poly_float process_wave_data_[vital::SynthOscillator::kSpectralBufferSize];
    const vital::Wavetable::WavetableData* current_wavetable_data_;
    int wavetable_index_;
 
    bool animate_;
    bool loading_wavetable_;
    bool last_loading_wavetable_;
    RenderType render_type_;
    RenderType last_render_type_;
    bool active_;
    int size_;
    int index_;
    vital::Wavetable* wavetable_;
 
    double current_value_;
    float vertical_angle_;
    float horizontal_angle_;
    float draw_width_percent_;
    float wave_height_percent_;
    float y_offset_;
 
    float wave_range_x_;
    float frame_range_x_;
    float wave_range_y_;
    float frame_range_y_;
    float start_x_;
    float start_y_;
    float offset_x_;
    float offset_y_;
 
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(Wavetable3d)
};