ReformerOscillator.h

Go to the documentation of this file.

/*
==============================================================================
 
        ReformerOscillator.cpp
        Sample based oscillator / reformer engine
        Author: Sandy
        Date: 19/08/2020
 
==============================================================================
*/
 
#pragma once
#include <mutex>
 
namespace krotos
{
    class ReformerOscillator : public Oscillator
    {
 
      public:
        ReformerOscillator();
 
        ~ReformerOscillator() override {}
 
        void setSampleRate(double sampleRate) override;
 
        void setBlockSize(size_t blockSize) { m_blockSize = blockSize; }
 
        double getSampleRate() override;
 
        void setFrequency(float frequency) override;
 
        float getFrequency() override;
 
        void setPhaseOffset(float /*offset*/) override {}
        void reset() override {}
        void setPhase(double /*phase*/) override {}
        double getPhase() override { return 0.0; }
 
        int getNumActiveGrains() override;
 
        StereoSample getNextStereoSample(size_t sampleIndex) override;
 
        // float getNextSample() override;
 
        void setGranularParameter(size_t paramIndex, const float* newValue);
 
        void setGranularParameters(std::vector<const float*>& newParams);
 
        void setSampleData(SampleEngine* sampleEngine);
 
        void startNote(int midiNote, float velocity, int voiceIndex);
 
        const float getVelocity();
 
        void stopNote();
 
        void clearNote();
 
        enum GranularParam
        {
            // Granular basics
            Start = 0,
            PuckX,
            PuckY,
            Nearest,
            StartRand,
            Size,
            SizeRand,
            Rate,
            RateRand,
            Width,
            WidthRand,
            Pan,
            PanRand,
            Detune,
            DetuneMod,
            DetuneRand,
            Level,
            GranularLevel,
            LevelMod,
            LevelRand,
            Popcorn,
            Quench,
            Robin,
            SALoop,
            Autoplay,
            Shape,
            GrainLim,
            Tracking,
            Normalise,
            Mute,
            Solo,
            Proximity,
            Radius,
            NUM_PARAMS
        };
 
        int getVoiceIndex() const { return m_voiceIndex; };
        bool isAutoplayEnabled() const { return m_autoplayEnabled; };
        bool isDrone() const { return m_isDrone; };
        bool isStopped() const { return m_stopped; };
        bool isKeyDown() const { return m_keyDown; };
 
      private:
        // Methods
 
        void flushGranular();
        float cube(float val);
        void setTaggingType(bool isOn);
        void setTrackingEnable(bool isOn);
        void setHardLoopEnable(bool isOn);
 
        void killNANs(StereoSample& sample);
        Grain* launchGrain(float paramSize, float paramStart, float paramSpray, Grain::Flavour flavour,
                           float gain = -1.f);
        double calculatePlayheadPosition(double startPosition, float halfSpray, float referenceGrainsize);
        float getRateRandFactor();
        StereoSample getNextStereoGranularSample();
 
        void generateGrains(StereoSample& sampleAccumulator);
 
        // Variables
        juce::Random m_rand{1234};
 
        // Generates grain timing
        PhaseGenerator m_voicePhase;
 
        // Used to restart loop mode when in popcorn mode
        PhaseGenerator m_popcornTimer;
 
        float m_playbackHz{0.0f};
        float m_playbackHzDetuned{0.0f}; // Desired frequency of note to be played back
 
        double m_samplerate{48000.0};
 
        float m_grainRate{0.0f};
        float m_StartIndex{0.0f};
        AudioDescriptor m_closestDescriptor;
        SampleEngine* m_sampleEngine{nullptr};
        std::vector<Grain*> m_activeGrains;
        int m_length{0};
        std::vector<const float*> m_parameters;
        bool m_stopped{false};
        bool m_keyDown{false};
 
        Point<float> m_puckPosition{0.f, 0.f};
        size_t m_blockSize{128};
 
        int m_voiceIndex{-1};
 
        SlewLimiter m_channelCrossfade;
        bool m_taggingType{false};
        bool m_trackingEnable{false};
        bool m_loopingEnable{false};
        bool m_normalisationEnable{false};
        size_t m_sampleIndex{0};
        float m_velocity{1.0f};
 
        // float value between 0.0-12.0f given by the ADSR applied on a Detune
        float m_detuneModVal{0.0f};
        const float AMPLITUDE_FIDDLE_FACTOR{0.6f};
        const float FADE_POINT_MIN{0.000001f};
        bool m_isDrone{false};
        bool m_autoplayEnabled{false};
 
        size_t m_nearestGrainIndex{0};
        size_t m_nearestPopGrainIndex{0};
 
        std::mt19937 m_g;
        std::size_t m_k{1};
        std::deque<size_t> m_grainHistory;
 
        // proximity mode
        bool m_proximityMode = false;
        bool m_proximityTrigger = false;
    };
} // namespace krotos