GrainVisualiser.cpp

Go to the documentation of this file.

#include "KrotosBinaryData.h"
 
namespace krotos
{
 
    GrainVisualiser::GrainVisualiser()
    {
        for (int i = 0; i < NUM_BACKGROUND_FRAMES; i++)
        {
            m_backgroundCache.push_back(Image(Image::ARGB, DISPLAY_WIDTH, DISPLAY_HEIGHT, true));
        }
 
        auto customBackdrop = File(AssetManager::getPluginDirectory().getFullPathName() + File::getSeparatorString() +
                                   "Graphics" + File::getSeparatorString() + "backdrop.png");
 
        if (customBackdrop.existsAsFile())
        {
            m_backdropImage = ImageFileFormat::loadFrom(customBackdrop);
        }
        else
        {
            m_backdropImage = ImageFileFormat::loadFrom(KrotosBinaryData::GrainBackdrop_png,
                                                        KrotosBinaryData::GrainBackdrop_pngSize);
        }
 
        auto customGrains = File(AssetManager::getPluginDirectory().getFullPathName() + File::getSeparatorString() +
                                 "Graphics" + File::getSeparatorString() + "Grains");
 
        if (customGrains.containsSubDirectories())
        {
            Array<File> directoryList = customGrains.findChildFiles(File::TypesOfFileToFind::findDirectories, false);
 
            for (const auto& directoryPath : directoryList)
            {
                File directory(directoryPath);
                String directoryName = directoryPath.getFullPathName();
 
                Array<File> filePaths = directory.findChildFiles(File::TypesOfFileToFind::findFiles, false, "*.png");
 
                Array<String> spriteNames;
 
                for (const auto& spritePath : filePaths)
                {
                    spriteNames.add(spritePath.getFileNameWithoutExtension());
                }
 
                std::vector<String> spriteNamesVector(spriteNames.begin(), spriteNames.end());
                std::sort(spriteNamesVector.begin(), spriteNamesVector.end());
 
                for (const auto& spriteName : spriteNamesVector)
                {
                    File spriteFile(directoryName + File::getSeparatorString() + spriteName + ".png");
                    m_grainImages.push_back(ImageFileFormat::loadFrom(spriteFile));
                }
            }
        }
        else
        {
            loadBinaryAssetGrainGraphics(DEFAULT_GRAIN_RENDER_STYLE);
        }
 
        // Copy the backdrop image into the dsiplay buffer as a default
        Graphics gContext(m_displayBuffer);
        drawBackdrop(gContext);
 
        SetTransformToFit(DISPLAY_WIDTH, DISPLAY_HEIGHT);
 
        // Forces redraw of background frames after GUI has been hidden by DAW then
        // revealed
        markBackgroundFramesDirty();
    }
 
    GrainVisualiser::~GrainVisualiser() {}
 
    void GrainVisualiser::drawGrain(Graphics& graphicContext, Graphics& overlayContext, float x, float y,
                                    float diameter, float sprite, float envelope)
    {
        bool bulgeEnabled = true;
        if (envelope < 0.f)
        {
            bulgeEnabled = false;
            envelope = 0.f;
        }
        float bulge = 1.f + envelope * 0.75f;
        float diam = jmap<float>(diameter, 0.f, 1.f, 0.01f, 0.1f);
        diam *= bulge * 2.f * m_grainDiameter;
        Rectangle<float> ellipseBounds{0.f, 0.f, diam * ASPECT_RATIO, diam};
        ellipseBounds.setCentre(x, 1.f - y);
 
        // If we have at least one grain image in the m_grainImages array ...
        float numSprites = static_cast<float>(m_grainImages.size());
        if (numSprites > 0.f)
        {
            if (bulgeEnabled)
            {
                graphicContext.setOpacity(envelope * m_grainAlpha);
                overlayContext.setOpacity(envelope * m_overlayAlpha);
            }
 
            graphicContext.setOpacity(1.f);
            overlayContext.setOpacity(1.f);
 
            // ...then draw in the grain from an image
            int spriteIndex = static_cast<int>((1.f - sprite) * numSprites);
            int maxSpriteIndex = static_cast<int>(numSprites) - 1;
 
            spriteIndex = std::max<int>(spriteIndex, 0);
            spriteIndex = std::min<int>(spriteIndex, maxSpriteIndex);
 
            if (m_advancedGraphics)
            {
                // Draw the bitmap
                drawNormalisedZoomedImage(graphicContext, m_grainImages[spriteIndex].image, ellipseBounds);
                // Now tint the bitmap
                drawNormalisedZoomedImage(overlayContext, m_grainImages[spriteIndex].image, ellipseBounds, true);
            }
            else // Legacy graphics
            {
                drawNormalisedZoomedImage(graphicContext, m_grainImages[spriteIndex].image, ellipseBounds);
            }
        }
        else
        {
            // ... otherwise draw an ellipse
            fillNormalisedZoomedEllipse(overlayContext, ellipseBounds); // Draw filled ellipse
            drawNormalisedZoomedEllipse(graphicContext, ellipseBounds); // Draw ellipse outline
        }
    }
 
    void GrainVisualiser::drawGrainPerspective(Graphics& graphicContext, Graphics& overlayContext, float x, float y,
                                               float z, float /*q*/, const AffineTransform& transform, float envelope)
    {
        float zDisplacement = m_advancedGraphics ? m_grainZ : 0.f;
        Point<float> slice{x - 0.5f, z - 0.5f + zDisplacement}; // Put X&Z location into a Point so we can rotate ...
        slice.applyTransform(transform);                        // ... rotate around Y
        float perspectiveScaling = jmap<float>(slice.y, -0.5f, 0.5f, PERSPECTIVE_SCALING_MAX, PERSPECTIVE_SCALING_MIN);
        drawGrain(graphicContext, overlayContext, (slice.x * perspectiveScaling) + 0.5f,
                  ((y - 0.5f) * perspectiveScaling) + 0.5f, 1.f - slice.y, y, envelope);
    }
 
    void GrainVisualiser::drawDisplayBuffer(juce::Graphics& g)
    {
        g.drawImage(m_displayBuffer, g.getClipBounds().toFloat());
    }
 
    void GrainVisualiser::drawBackdrop(juce::Graphics& g) { g.drawImage(m_backdropImage, g.getClipBounds().toFloat()); }
 
    inline int GrainVisualiser::calcBaseFrame(const float parallax, float& interFrame)
    {
        jassert(parallax >= 0 && parallax <= 1.f);
        float fractionalFrame = parallax * BACKGROUND_INTERPOLATION_SPAN;
        int baseFrame = static_cast<int>(fractionalFrame);
        jassert(baseFrame >= 0 && baseFrame < (NUM_BACKGROUND_FRAMES - 1));
        interFrame = fractionalFrame - static_cast<float>(baseFrame);
        jassert(interFrame >= 0.f && interFrame < 1.f);
        return baseFrame;
    }
 
    inline int GrainVisualiser::calcBaseFrame(const float parallax)
    {
        float interFrame;
        return calcBaseFrame(parallax, interFrame);
    }
 
    void GrainVisualiser::drawInterpolatedBackground(juce::Graphics& g, float parallax)
    {
        float interFrame;
        int baseFrame = calcBaseFrame(parallax, interFrame);
 
        // Only draw in the background if both frames are valid
        if (!m_backgroundCache[baseFrame].dirty && !m_backgroundCache[baseFrame + 1].dirty)
        {
            g.setColour(Colours::white);
            g.drawImageAt(m_backgroundCache[baseFrame].image, 0, 0);
            g.setOpacity(interFrame);
            g.drawImageAt(m_backgroundCache[baseFrame + 1].image, 0, 0);
        }
    }
 
    void GrainVisualiser::drawBackdropGradient(juce::Graphics& g)
    {
        auto backColour = getLookAndFeel().findColour(ResizableWindow::backgroundColourId);
        juce::ColourGradient cg = juce::ColourGradient::vertical(
                backColour.darker(0.5f), 0.0f, backColour.brighter(0.2f), static_cast<float>(getHeight()));
        g.setGradientFill(cg);
        g.fillAll();
    }
 
#if JUCE_DEBUG
    void GrainVisualiser::drawProgressTracker(juce::Graphics& g, ProgressTracker& progessTracker)
    {
        // Draw in the progress indicator
        float alpha = 1.0f; // Make the pie chart fully opaque
        drawBackdrop(g);
 
        // Make size and position rectangle for our pie chart
        Rectangle<float> pieBounds = Rectangle<int>{0, 0, DISPLAY_WIDTH, DISPLAY_HEIGHT}.toFloat().getProportion(
                Rectangle<float>{0.25f, 0.25f, .5f, 0.5f});
 
        // Draw the filled part of the pie chart
        Path pie;
        pie.addPieSegment(pieBounds, 0.f, progessTracker.getFilledIndicator() * TWO_PI, 0.f);
        g.setColour(getLookAndFeel().findColour(ResizableWindow::backgroundColourId).withAlpha(alpha));
        g.fillPath(pie);
 
        // Draw in the loding pie slice with rotating colours
        pie.clear();
        pie.addPieSegment(pieBounds, progessTracker.getIndicator() * 6.28319f,
                          progessTracker.getFilledIndicator() * TWO_PI, 0.f);
        m_indicatorHue += 0.01f; // Rotate the hue of the loading segment
        if (m_indicatorHue > 1.0f)
            m_indicatorHue = 0.f;
        g.setColour(Colour::fromHSV(m_indicatorHue, 0.5f, 0.6f, 1.f).withAlpha(alpha));
        g.fillPath(pie);
 
        // Draw the outlined part of the pie chart
        pie.clear();
        pie.addPieSegment(pieBounds, 0.f, progessTracker.getIndicator() * TWO_PI, 0.f);
        g.setColour(getLookAndFeel().findColour(ResizableWindow::backgroundColourId).brighter(0.5f).withAlpha(alpha));
        g.strokePath(pie, PathStrokeType(2.f));
 
        // Draw in the progress message
        g.setColour(Colours::white.withAlpha(alpha));
        Rectangle<float> textBounds;
        textBounds.setSize(0.5f, 0.05f);
        textBounds.setPosition(0.2f, 0.8f);
        drawNormalisedZoomedText(g, progessTracker.getMessage(), textBounds);
    }
#endif
 
    void GrainVisualiser::drawBackgroundFrame(Graphics& graphicContext, Graphics& overlayContext,
                                              SampleEngineShallow* sampleEngine, float parallax)
    {
        std::vector<AudioDescriptor>& grainDescriptionByZ = sampleEngine->getGrainDescriptionByZ();
 
#if JUCE_DEBUG
        // Draw in the frame number and num grains
        graphicContext.setColour(Colours::white.withAlpha(0.2f));
        Rectangle<float> textBounds;
        textBounds.setSize(0.5f, 0.05f);
        textBounds.setPosition(0.25f, 0.95f);
        drawNormalisedZoomedText(graphicContext,
                                 "Grains: " + String(grainDescriptionByZ.size()) +
                                         "   Frame: " + String(m_redrawFrameIndex),
                                 textBounds);
#endif
 
        auto transform = makeParallaxRotationTransform(parallax);
 
        // Draw in every grain
        for (auto& grainDescription : grainDescriptionByZ)
        {
            drawGrainPerspective(graphicContext, overlayContext, grainDescription.principalX,
                                 grainDescription.principalY, grainDescription.principalZ, grainDescription.principalQ,
                                 transform);
        }
    }
 
    void GrainVisualiser::paint(juce::Graphics& g)
    {
        m_parallaxFromPuck = m_puckPositionX;
 
        // Draw in the background from pre-rendered frames
        Graphics displayBufferContext(m_displayBuffer); // Get a graphics context
        drawInterpolatedBackground(displayBufferContext, m_parallaxFromPuck);
 
        // Search for dirty background frames
        // This finds the first frame which is flagged as dirty - in other words the first
        // frame which needs to be re-drawn. An index to this frame will be kept in m_redrawFrameIndex
        // where it will trigger a re-draw. It is done like this so that only one frame is drawn
        // during each paint() call, and during successive calls to paint(), we will work our way through
        // the dirty frames, redrawing them one at a time, marking them not dirty as we go.
        // This helps prevent each call to paint() taking too long.
        for (int i = 0; i < NUM_BACKGROUND_FRAMES; i++)
        {
            int testFrame = (i + calcBaseFrame(m_parallaxFromPuck)) % NUM_BACKGROUND_FRAMES;
            if (m_backgroundCache[testFrame].dirty)
            {
                m_redrawFrameIndex = testFrame;
                // found a dirty frame, no need to search further, and we keep its index in m_redrawFrameIndex
                break;
            }
        }
 
        if (m_redrawFrameIndex >= 0)
        {
            // If there is any frame which is not drawn yet, we switch off the display by making it transparent
            m_globalDisplayOpacity = 0.f;
        }
        else
        {
            // Otherwise we know they are all drawn, and we start fading up the display by incrementing opacity
            m_globalDisplayOpacity += 1.f / NUM_GLOBAL_FADE_UP_FRAMES;
            // but don't fade up greater than 1.0
            if (m_globalDisplayOpacity > 1.f)
            {
                m_globalDisplayOpacity = 1.f;
            }
        }
 
        bool shouldRegenerateDisplayCache = false;
 
        // Loop through the array of pointers to sound data instances
        for (auto& engine : m_shallowEngineArray)
        {
            if (engine.getGrainDescriptionByZ().size() > 0) // If there are background grains
            {
                // Is it asking for regeneration of the background cache ?
                if (engine.shouldRegenerateDisplayCache())
                {
                    // If any single engine asks for cache regeneration we trigger
                    // regeneration of the entire cache
                    shouldRegenerateDisplayCache = true;
                }
                else
                {
                    // We use the sample engine data to paint a frame into the display buffer
                    paintPlayingGrains(&engine);
                }
            }
        }
 
        if (m_redrawFrameIndex >= 0)
        {
            m_backgroundCache[m_redrawFrameIndex].dirty = false;
            m_redrawFrameIndex = -1;
        }
 
        if (shouldRegenerateDisplayCache || m_requestBackgroundCacheRegeneration)
        {
            m_requestBackgroundCacheRegeneration = false; // Acknowledge request
            markBackgroundFramesDirty();                  // We mark all the frames as dirty
            m_globalDisplayOpacity = 0.f;                 // Lets not be looking at dirty frames
        }
 
        drawDisplayBuffer(g); // Draw the display buffer into the supplied graphics context
 
        // In perform mode we hide semi-complete background cacheing using display opacity
        // In edit mode we want to see frames as soon as they are generated
        if (m_performMode)
        {
            // This mechanism allows the entire display to be faded up against the backdrop
            if (m_globalDisplayOpacity != 1.f)
            {
                g.setOpacity(1.f - m_globalDisplayOpacity);
                drawBackdrop(g);
            }
        }
    }
 
    void SampleEngineShallow::shallowCopy(SampleEngine* sampleEngine)
    {
        m_shouldRegenerateDisplayCache = sampleEngine->shouldRegenerateDisplayCache();
        m_analysisResultsAreValid = sampleEngine->analysisResultsAreValid();
        m_grainDescriptionByZ = sampleEngine->getGrainDescriptionByZ();
        m_analysisCoefficients = sampleEngine->getAnalysisCoefficients();
#if JUCE_DEBUG
        m_progressTracker = sampleEngine->getProgressTracker();
#endif
        Grain* grainArray = sampleEngine->getGrainArray();
        m_grains.clear();
        for (int i = 0; i < SampleEngine::MAX_NUM_GRAINS; i++)
        {
            // We will keep copies only of grains which are playing
            if (grainArray[i].isPlaying)
            {
                m_grains.push_back(grainArray[i]);
            }
        }
    }
 
    const AffineTransform GrainVisualiser::makeParallaxRotationTransform(float parallax)
    {
        return AffineTransform().rotated((parallax -= 0.5f) * -ROTATION_RANGE);
    }
 
    void GrainVisualiser::paintPlayingGrains(SampleEngineShallow* sampleEngine)
    {
        jassert((sampleEngine != nullptr) && (isEnabled() == true));
 
        // Create two contexts to the display buffer, so we can set a different colour on each
        Graphics graphicContext(m_displayBuffer);
        Graphics overlayContext(m_displayBuffer);
 
        // If there are valid analysis results available
        if (sampleEngine->analysisResultsAreValid())
        {
            m_grainZ = (sampleEngine->getAnalysisCoefficients().coeff5 - 0.5f) * Z_SEPARATION_SCALING;
            m_grainDiameter = sampleEngine->getAnalysisCoefficients().coeff6;
 
            m_grainAlpha = sampleEngine->getAnalysisCoefficients().dispAAlpha;
            m_overlayHue = sampleEngine->getAnalysisCoefficients().dispAH;
            m_overlayAlpha = sampleEngine->getAnalysisCoefficients().dispAA;
 
            m_advancedGraphics = m_grainAlpha || m_overlayAlpha;
 
            if (!m_advancedGraphics)
            {
                m_grainAlpha = LEGACY_MODE_ALPHA_VALUE;
            }
 
            // If necessary regenerate dirty background cached frame
            if (m_redrawFrameIndex >= 0)
            {
                updateBackgroundCacheFrame(sampleEngine, m_redrawFrameIndex);
            }
 
            // Setting colour here so we don't have to do it inside the grain drawing loop
            if (m_advancedGraphics)
            {
                graphicContext.setColour(Colours::white.withAlpha(m_grainAlpha));
                overlayContext.setColour(Colour::fromHSV(m_overlayHue, 1.0f, 1.0f, m_overlayAlpha));
            }
            else
            {
                graphicContext.setColour(Colours::white.withAlpha(LEGACY_MODE_ALPHA_VALUE));
            }
 
            auto transform = makeParallaxRotationTransform(m_parallaxFromPuck);
 
            for (Grain& grain : sampleEngine->getGrainArray())
            {
                drawGrainPerspective(graphicContext, overlayContext, grain.principalX, grain.principalY,
                                     grain.principalZ, grain.principalQ, transform, grain.envelope);
            }
        }
        else // There are no valid analysis results available
        {
#if JUCE_DEBUG
            // If we are in perform mode, we only draw in the background
            if (m_performMode)
            {
                drawBackdrop(graphicContext);
            }
            // If we are in edit mode, we draw in the progress tracker
            else
            {
                auto progessTracker = sampleEngine->getProgressTracker();
                // If loading/analysis is in progress
                if (progessTracker.isLoading())
                {
                    drawProgressTracker(graphicContext, progessTracker);
                }
            }
#else
            m_globalDisplayOpacity = 0.f; // Lets not be displaying grains when analysis invalid
#endif
        }
    }
 
    void GrainVisualiser::updateBackgroundCacheFrame(SampleEngineShallow* sampleEngine, int index)
    {
        // Create an angle value to rotate the display as we iterate though the frames
        float parallax = static_cast<float>(index) / static_cast<float>(NUM_BACKGROUND_FRAMES);
 
        // Then draw in the background plus all the grains
        Graphics graphicContext(m_backgroundCache[index].image);
        Graphics overlayContext(m_backgroundCache[index].image);
 
        if (m_advancedGraphics)
        {
            graphicContext.setColour(Colours::white.withAlpha(m_grainAlpha));
            overlayContext.setColour(Colour::fromHSV(m_overlayHue, 1.0f, 1.0f, m_overlayAlpha));
        }
        else
        {
            graphicContext.setColour(Colours::white.withAlpha(LEGACY_MODE_ALPHA_VALUE));
            overlayContext.setOpacity(0.f);
        }
        drawBackgroundFrame(graphicContext, overlayContext, sampleEngine, parallax);
    }
 
    void GrainVisualiser::markBackgroundFramesDirty()
    {
        // Mark all the background frames as dirty
        for (auto& backGround : m_backgroundCache)
        {
            // Get a graphics context for the background frame buffer which we want to draw into
            Graphics gContext(backGround.image);
            drawBackdrop(gContext);
            backGround.dirty = true;
        }
    }
 
    void GrainVisualiser::loadBinaryAssetGrainGraphics(GrainRenderStyle style)
    {
        std::vector<const char*> imageArray;
        std::vector<size_t> imageSizeArray;
 
        switch (style)
        {
        case GrainRenderStyle::Compound:
            imageArray = {KrotosBinaryData::Compound_0_png, KrotosBinaryData::Compound_01_png,
                          KrotosBinaryData::Compound_02_png, KrotosBinaryData::Compound_03_png,
                          KrotosBinaryData::Compound_04_png};
 
            imageSizeArray = {KrotosBinaryData::Compound_0_pngSize, KrotosBinaryData::Compound_01_pngSize,
                              KrotosBinaryData::Compound_02_pngSize, KrotosBinaryData::Compound_03_pngSize,
                              KrotosBinaryData::Compound_04_pngSize};
            break;
        default:
        case GrainRenderStyle::DotsWithLines:
            imageArray = {KrotosBinaryData::DotsWithLines_01_png, KrotosBinaryData::DotsWithLines_02_png,
                          KrotosBinaryData::DotsWithLines_03_png};
 
            imageSizeArray = {KrotosBinaryData::DotsWithLines_01_pngSize, KrotosBinaryData::DotsWithLines_02_pngSize,
                              KrotosBinaryData::DotsWithLines_03_pngSize};
            break;
        }
 
        for (size_t i = 0; i < imageArray.size(); ++i)
        {
            m_grainImages.push_back(ImageFileFormat::loadFrom(imageArray[i], imageSizeArray[i]));
        }
    }
 
} // namespace krotos