wave_source.h

Go to the documentation of this file.

/*
Summary:
WaveSource and WaveSourceKeyframe provide a direct representation of wavetables via WaveFrames. By storing entire waveforms and supporting time or frequency domain interpolation (including cubic methods for smoothness), they enable flexible and sophisticated transitions between keyframes. This results in dynamic and evolving sounds that can be tailored by controlling interpolation modes and parameters.
 */
 
#pragma once
 
#include "JuceHeader.h"
#include "wavetable_component.h"
#include "wave_frame.h"
 
class WaveSourceKeyframe;
 
class WaveSource : public WavetableComponent {
  public:
    enum InterpolationMode {
        kTime,      
        kFrequency  
    };
 
    WaveSource();
    virtual ~WaveSource();
 
    WavetableKeyframe* createKeyframe(int position) override;
    void render(vital::WaveFrame* wave_frame, float position) override;
    WavetableComponentFactory::ComponentType getType() override;
    json stateToJson() override;
    void jsonToState(json data) override;
 
    vital::WaveFrame* getWaveFrame(int index);
 
    WaveSourceKeyframe* getKeyframe(int index);
 
    void setInterpolationMode(InterpolationMode mode) { interpolation_mode_ = mode; }
 
    InterpolationMode getInterpolationMode() const { return interpolation_mode_; }
 
protected:
    std::unique_ptr<WaveSourceKeyframe> compute_frame_; 
    InterpolationMode interpolation_mode_;              
 
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(WaveSource)
};
 
class WaveSourceKeyframe : public WavetableKeyframe {
public:
    WaveSourceKeyframe() : interpolation_mode_(WaveSource::kFrequency) {
        wave_frame_ = std::make_unique<vital::WaveFrame>();
    }
    virtual ~WaveSourceKeyframe() { }
 
    vital::WaveFrame* wave_frame() { return wave_frame_.get(); }
 
    void copy(const WavetableKeyframe* keyframe) override;
 
    void linearTimeInterpolate(const vital::WaveFrame* from, const vital::WaveFrame* to, float t);
 
    void cubicTimeInterpolate(const vital::WaveFrame* prev, const vital::WaveFrame* from,
                              const vital::WaveFrame* to, const vital::WaveFrame* next,
                              float range_prev, float range, float range_next, float t);
 
    void linearFrequencyInterpolate(const vital::WaveFrame* from, const vital::WaveFrame* to, float t);
 
    void cubicFrequencyInterpolate(const vital::WaveFrame* prev, const vital::WaveFrame* from,
                                   const vital::WaveFrame* to, const vital::WaveFrame* next,
                                   float range_prev, float range, float range_next, float t);
 
    void interpolate(const WavetableKeyframe* from_keyframe, const WavetableKeyframe* to_keyframe, float t) override;
    void smoothInterpolate(const WavetableKeyframe* prev_keyframe,
                           const WavetableKeyframe* from_keyframe,
                           const WavetableKeyframe* to_keyframe,
                           const WavetableKeyframe* next_keyframe, float t) override;
 
    void render(vital::WaveFrame* wave_frame) override {
        wave_frame->copy(wave_frame_.get());
    }
 
    json stateToJson() override;
    void jsonToState(json data) override;
 
    void setInterpolationMode(WaveSource::InterpolationMode mode) { interpolation_mode_ = mode; }
 
    WaveSource::InterpolationMode getInterpolationMode() const { return interpolation_mode_; }
 
protected:
    std::unique_ptr<vital::WaveFrame> wave_frame_;         
    WaveSource::InterpolationMode interpolation_mode_;     
 
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(WaveSourceKeyframe)
};