GrainVisualiser.h

Go to the documentation of this file.

#pragma once
 
namespace krotos
{
 
    struct KrotosImage
    {
      public:
        KrotosImage(Image initImage) : image{initImage} {}
        Image image;
        bool dirty{true}; // True indicates that the image is out of date
    };
 
    class SampleEngineShallow
    {
      public:
        void shallowCopy(SampleEngine* sampleEngine);
 
#if JUCE_DEBUG
        ProgressTracker& getProgressTracker() { return m_progressTracker; }
#endif
 
        std::vector<AudioDescriptor>& getGrainDescriptionByZ() { return m_grainDescriptionByZ; }
 
        bool shouldRegenerateDisplayCache() { return m_shouldRegenerateDisplayCache; }
 
        bool analysisResultsAreValid() { return m_analysisResultsAreValid; }
 
        std::vector<Grain>& getGrainArray() { return m_grains; }
 
        AnalysisCoefficients& getAnalysisCoefficients() { return m_analysisCoefficients; }
 
        std::vector<Grain> m_grains;
 
      private:
        std::vector<AudioDescriptor> m_grainDescriptionByZ;
        bool m_shouldRegenerateDisplayCache{false};
        AnalysisCoefficients m_analysisCoefficients;
        bool m_analysisResultsAreValid{false};
#if JUCE_DEBUG
        ProgressTracker m_progressTracker;
#endif
    };
 
    class GrainVisualiser : public ZoomableComponent
    {
      public:
        // Upper limit to how many Reformer instances we are prepared to display
        // Instances beyond this number will be ignored
        static constexpr int ReformerMaxDisplayedInstances{4};
 
        GrainVisualiser();
        ~GrainVisualiser() override;
 
        void drawGrain(Graphics& graphicContext, Graphics& overlayContext, float x, float y, float diameter,
                       float sprite, float envelope = 0.f);
 
        void drawGrainPerspective(Graphics& graphicContext, Graphics& overlayContext, float x, float y, float z,
                                  float q, const AffineTransform& transform, float envelope = -1.f);
 
        void drawBackdropGradient(juce::Graphics& g);
 
        void drawBackdrop(juce::Graphics& g);
 
        int calcBaseFrame(const float parallax, float& interFrame);
 
        int calcBaseFrame(float parallax);
 
        void drawInterpolatedBackground(juce::Graphics& g, float parallax);
 
        void drawDisplayBuffer(juce::Graphics& g);
 
#if JUCE_DEBUG
        void drawProgressTracker(juce::Graphics& g, ProgressTracker& progessTracker);
#endif
 
        const AffineTransform makeParallaxRotationTransform(float parallax);
 
        void paint(Graphics& g) override;
 
        void updateBackgroundCacheFrame(SampleEngineShallow* sampleEngine, int index);
 
        void requestBackgroundCacheRegeneration() { m_requestBackgroundCacheRegeneration = true; }
 
        void paintPlayingGrains(SampleEngineShallow* sampleEngine);
 
        void drawBackgroundFrame(Graphics& graphicContext, Graphics& overlayContext, SampleEngineShallow* sampleEngine,
                                 float parallax);
 
        void markBackgroundFramesDirty();
 
        void prepareToAddSampleEngines()
        {
            // More stuff will go in here when we
            m_shallowEngineArray.clear();
        }
 
        void finishedAddingSampleEngines()
        {
            // If the number of active engines changes, we need to re-draw the background frames
            if (m_shallowEngineArray.size() != m_numActiveEngines)
            {
                m_numActiveEngines = m_shallowEngineArray.size();
                markBackgroundFramesDirty();
            }
        }
 
        void shallowCopy(KrotosSampleOscillatorSound* sound)
        {
            auto engine = sound->getSampleEngine();
            // For the pusposes of grain drawing, we treat an engine with no audio segments
            // exactly like it is no engine at all. It is not pushed onto the array
            // This allows detection of the active engine count to trigger a background
            // redraw if an engine's segment count is reduced to zero
            if (engine->getNumAudioSegments() > 0)
            {
                m_shallowEngineArray.push_back(SampleEngineShallow());
                m_shallowEngineArray.back().shallowCopy(sound->getSampleEngine());
            }
        }
 
        void setPuckPosition(Point<float> position)
        {
            m_puckPositionX = position.x;
            m_puckPositionY = position.y;
        }
 
        void setPerformMode(bool val) { m_performMode = val; }
 
        enum GrainRenderStyle
        {
            Compound = 0,
            DotsWithLines,
            NUM_GRAIN_STYLES
        };
 
        void loadBinaryAssetGrainGraphics(GrainRenderStyle style);
 
      private:
        // Overall control over the tansparency of the grain display
        float m_globalDisplayOpacity{0.f};
        // The num frames taken to fade back up after global fade to transparent
        const float NUM_GLOBAL_FADE_UP_FRAMES{10.f};
 
        const GrainRenderStyle DEFAULT_GRAIN_RENDER_STYLE{GrainRenderStyle::DotsWithLines};
 
        bool m_performMode{false};
 
        float m_parallaxFromPuck{0.f};
        volatile std::atomic<float> m_puckPositionX;
        volatile std::atomic<float> m_puckPositionY;
 
        CriticalSection objectLock;
 
        float m_indicatorHue{0.f}; // For animated hue changes in the progress pie display
 
        const float ROTATION_RANGE{0.7f}; // The range in radians through which the
                                          // ML blob display can be rotated
 
        const float PERSPECTIVE_SCALING_MIN{0.8f}; // A very cheap pseudo perspective - the scaling
        const float PERSPECTIVE_SCALING_MAX{1.0f}; // factor for the back of the cube
 
        const float ASPECT_RATIO{1.0f}; // Match the aspect ratio of the grain display
                                        // to make grain blob ellipses circular
        const float TWO_PI{6.28319f};   // A famous number multiplied by 2
 
        const float Z_SEPARATION_SCALING{-0.4f}; // Fine tuning of the effect of the depth separation slider
 
        const float LEGACY_MODE_ALPHA_VALUE{0.55f};
 
        // The background is cached into an array of images (background frames) with different degrees of
        // rotation for CPU economy. The more frames we use, the longer it will take to render the array
        // We make the most of every frame by cross-dissolving between frames to represent angles
        // inbetween the ones represented by the frames. Try to keep NUM_BACKGROUND_FRAMES as low as you can
        // without causing unacceptable "ghosting" caused by the cross-dissolving
        const int NUM_BACKGROUND_FRAMES{12}; // Number of cached frames we require
        const float SMALLEST_FLOAT_VALUE{0.000001f};
        const float BACKGROUND_INTERPOLATION_SPAN{(NUM_BACKGROUND_FRAMES - 1) - SMALLEST_FLOAT_VALUE};
        bool m_requestBackgroundCacheRegeneration{false};
        std::vector<KrotosImage> m_backgroundCache; // Vector of cached background frames
 
        const int DISPLAY_WIDTH{240};
        const int DISPLAY_HEIGHT{240};
 
        float m_grainDiameter{1.f};
        float m_overlayHue{0.f};
        float m_overlayAlpha{0.f};
        float m_grainAlpha{0.f};
        float m_grainZ{0.f};
        bool m_advancedGraphics{false};
 
        Image m_backdropImage{Image(Image::ARGB, DISPLAY_WIDTH, DISPLAY_HEIGHT, true)}; // Pre-loaded backgdrop image
 
        // We buffer the final rendered image of background plus playing grains, so that whenever the system calls
        // paint() we can instantly paint an image of background and grains. This is required because we have several
        // layered components, of which this is only one, which the system composits. (This plus the cursor and user
        // messages for instance.
        Image m_displayBuffer{Image(Image::ARGB, DISPLAY_WIDTH, DISPLAY_HEIGHT, true)}; // Display is painted into here
 
        std::vector<KrotosImage> m_grainImages; // Vector of images used to portray grains in the grain visualiser
 
        int m_redrawFrameIndex{-1};
 
        std::vector<SampleEngineShallow> m_shallowEngineArray;
        int m_numActiveEngines{0};
    };
} // namespace krotos