GrainDisplay.cpp

Go to the documentation of this file.

#include "GrainDisplay.h"
 
namespace krotos
{
    const String GrainDisplay::GRAIN_DISPLAY_UPDATE_ID{"GrainDisplay::update"};
 
    GrainDisplay::GrainDisplay()
    {
        for (int i = 0; i < MAX_DRAWN_GRAINS; i++)
        {
            m_grainIndices[i] = -1;
        }
    }
 
    GrainDisplay::~GrainDisplay() {}
 
    void GrainDisplay::update()
    {
        if (m_sampleOscillatorSound == nullptr)
            return;
 
        if (m_sampleOscillatorSound->requestAccess(GRAIN_DISPLAY_UPDATE_ID))
        {
            organiseGrains();
            repaint();
 
            m_sampleOscillatorSound->finishedAccessing(GRAIN_DISPLAY_UPDATE_ID);
        }
    }
 
    Range<float> GrainDisplay::getPlayingWaveformZoomRange()
    {
        if (m_sampleEngine != nullptr)
        {
            return m_sampleEngine->getPlayingWaveformZoomRange();
        }
        return Range<float>(0.f, 1.f);
    }
 
    AreaSelectionComp::WaveformMode GrainDisplay::getWaveformMode()
    {
        if (m_sampleEngine == nullptr || m_sampleEngine->getNumAudioSegments() > 1)
        {
            return AreaSelectionComp::WaveformMode::noLine;
        }
        else
        {
            return static_cast<AreaSelectionComp::WaveformMode>(m_sampleEngine->getGranularOscillatorTypeIndicator());
        }
    }
 
    void GrainDisplay::organiseGrains()
    {
        if (m_grainArray == nullptr)
        {
            // no grains to organise
            return;
        }
 
        int grainIndex = 0;
        for (int i = 0; i < MAX_DRAWN_GRAINS; i++)
        {
            if (m_grainIndices[i] == -1 || m_grainArray[m_grainIndices[i]].isPlaying == false)
            {
                // change grain
                for (int j = grainIndex; j < SampleEngine::MAX_NUM_GRAINS; j++)
                {
                    if (checkGrain(j) == true)
                    {
                        float trans = m_grainArray[j].grainWindow;
 
                        if (trans > 0.1f)
                        {
                            // only looking for new-ish grains
                            continue;
                        }
 
                        m_grainIndices[i] = j;
                        grainIndex = j + 1;
                        break;
                    }
                }
            }
        }
    }
 
    bool GrainDisplay::checkGrain(int index)
    {
        if (m_grainArray != nullptr)
        {
            if (m_grainArray[index].isPlaying == true)
            {
                for (int i = 0; i < MAX_DRAWN_GRAINS; i++)
                {
                    if (m_grainIndices[i] == index)
                    {
                        // already drawing this grain
                        return false;
                    }
                }
                return true;
            }
        }
        return false;
    }
 
    void GrainDisplay::paint(juce::Graphics& g)
    {
        static const int NUM_WAVELET_SAMPLES{100};
 
        // sanity check
        if (m_sampleEngine == nullptr)
        {
            return;
        }
 
        if (this->isEnabled() == false || !m_sampleEngine->getNumAudioSegments())
        {
            // if not enabled don't draw
            return;
        }
 
        String sDisplay;
 
        if (m_grainArray != nullptr)
        {
            bool showEggs{false};
            bool showPlayheads{true};
 
            switch (m_sampleEngine->getGranularOscillatorTypeIndicator())
            {
            case GranularPlaybackMode::MGranular:
                showEggs = false;
                showPlayheads = true;
                break;
            case GranularPlaybackMode::MSampler:
                showEggs = false;
                showPlayheads = true;
                break;
            case GranularPlaybackMode::MVehicle:
                showEggs = true;
                showPlayheads = false;
                break;
            }
 
            bool isFirstPlayingGrain = true;
            float waveletSamples[NUM_WAVELET_SAMPLES];
            bool waveletSamplesValid = false;
 
            for (int i = 0; i < MAX_DRAWN_GRAINS; i++)
            {
                if (m_grainArray[m_grainIndices[i]].isPlaying == true)
                {
                    if (m_grainIndices[i] >= 0)
                    {
                        float grainHeight = jlimit<float>(0.f, 1.f, m_grainArray[m_grainIndices[i]].envelope);
                        float halfGrainHeight = grainHeight * 0.5f;
 
                        if (showEggs)
                        {
                            // Draw filled ellipse around entire grain region
                            float positionStartPercent =
                                    m_grainArray[m_grainIndices[i]].playHeadStart / (float)m_numSamples;
                            float widthPercent = m_grainArray[m_grainIndices[i]].length / (float)m_numSamples;
                            if (m_grainArray[m_grainIndices[i]].flavour == Grain::Flavour::vehicleMoving)
                            {
                                g.setColour(Colours::green.withAlpha(1.0f));
                            }
                            else if (m_grainArray[m_grainIndices[i]].flavour == Grain::Flavour::vehicleStatic)
                            {
                                g.setColour(Colours::red.withAlpha(1.0f));
                            }
                            else if (m_grainArray[m_grainIndices[i]].flavour == Grain::Flavour::background)
                            {
                                g.setColour(Colours::violet.withAlpha(0.2f));
                            }
                            else
                            {
                                g.setColour(Colours::orange.withAlpha(0.2f));
                            }
                            drawNormalisedZoomedEllipse(
                                    g, {positionStartPercent,
                                        0.5f - m_grainArray[m_grainIndices[i]].mix * grainHeight * 0.5f, widthPercent,
                                        m_grainArray[m_grainIndices[i]].mix * grainHeight});
                        }
                        const bool hasSampleAccess = m_sampleOscillatorSound != nullptr &&
                                                     m_sampleOscillatorSound->requestAccess(GRAIN_DISPLAY_UPDATE_ID);
                        if (showPlayheads && hasSampleAccess)
                        {
                            // Draw in the playheads for each of the channels in the sample
                            float position = m_grainArray[m_grainIndices[i]].playHeadStart +
                                             m_grainArray[m_grainIndices[i]].grainWindow *
                                                     m_grainArray[m_grainIndices[i]].length;
                            float percentage = (position / (float)m_numSamples);
                            float centerHeight = 0.5f;
 
                            if (position >= 0)
                            {
                                g.setColour(m_playheadColour);
 
                                if (m_drawDebugGraphics)
                                {
                                    if (m_grainArray[m_grainIndices[i]].flavour == Grain::Flavour::background)
                                    {
                                        g.setColour(Colours::yellow.withAlpha(
                                                jmin<float>(0.25f + halfGrainHeight * 2.0f, 1.f)));
                                    }
                                    else
                                    {
                                        g.setColour(Colours::lightgoldenrodyellow.withAlpha(
                                                jmin<float>(0.25f + halfGrainHeight * 2.0f, 1.f)));
                                    }
                                    drawNormalisedZoomedLine(g,
                                                             {percentage, centerHeight + halfGrainHeight, percentage,
                                                              centerHeight - halfGrainHeight},
                                                             2);
 
                                    int voiceIndex = m_grainArray[m_grainIndices[i]].voiceIndex;
                                    if (voiceIndex >= 0)
                                    {
                                        Rectangle<float> voiceIndexBounds;
                                        voiceIndexBounds.setPosition(percentage + 0.005f, centerHeight);
                                        voiceIndexBounds.setSize(0.2f, 0.3f);
                                        drawNormalisedZoomedText(g, String(voiceIndex + 1), voiceIndexBounds);
                                    }
 
                                    // Draw indicator for audio ADSR output value
                                    float yPosition = 1.f - m_grainArray[m_grainIndices[i]].gainMod;
                                    g.setColour(Colours::cyan);
                                    drawNormalisedZoomedLine(
                                            g, {percentage - 0.01f, yPosition, percentage + 0.01f, yPosition}, 2);
 
                                    // Draw indicator for pitch ADSR output value
                                    yPosition = 1.f - m_grainArray[m_grainIndices[i]].pitchMod;
                                    g.setColour(Colours::magenta);
                                    drawNormalisedZoomedLine(
                                            g, {percentage - 0.01f, yPosition, percentage + 0.01f, yPosition}, 2);
                                }
                                else
                                {
                                    if (m_sampleEngine->getGranularOscillatorTypeIndicator() ==
                                        GranularPlaybackMode::MSampler)
                                    {
                                        drawNormalisedZoomedLine(g, {percentage, 0.0f, percentage, 1.0f}, 2);
                                    }
                                    else
                                    {
                                        drawNormalisedZoomedLine(g,
                                                                 {percentage, centerHeight + halfGrainHeight,
                                                                  percentage, centerHeight - halfGrainHeight},
                                                                 2);
                                    }
                                }
                            }
                            // finish accessing the sample
                            m_sampleOscillatorSound->finishedAccessing(GRAIN_DISPLAY_UPDATE_ID);
                        }
 
                        if (isFirstPlayingGrain)
                        {
                            isFirstPlayingGrain = false;
 
                            float startIndex = static_cast<float>(m_grainArray[m_grainIndices[i]].playHeadStart);
                            float increment = static_cast<float>(m_grainArray[m_grainIndices[i]].grainSize /
                                                                 static_cast<float>(NUM_WAVELET_SAMPLES));
 
                            float min = 1000.f, max = -1000.f;
                            for (int wSample = 0; wSample < NUM_WAVELET_SAMPLES; wSample++)
                            {
                                waveletSamples[wSample] = m_sampleEngine->getSample(0, startIndex);
 
                                if (waveletSamples[wSample] < min)
                                    min = waveletSamples[wSample];
                                if (waveletSamples[wSample] > max)
                                    max = waveletSamples[wSample];
 
                                startIndex += increment;
                                if (static_cast<int>(startIndex) > m_sampleEngine->getNumSamples() - 1)
                                    break;
                            }
 
                            if (max > min) // Sanity check
                            {
                                for (int wSample = 0; wSample < NUM_WAVELET_SAMPLES; wSample++)
                                {
                                    waveletSamples[wSample] = jmap<float>(waveletSamples[wSample], min, max, 0.f, 1.f);
                                }
                                waveletSamplesValid = true;
                            }
                        }
                    }
                }
            } // Every grain
 
            // Draw in sample engine data if there is any (red line)
            if (m_sampleEngine->getGranularOscillatorTypeIndicator() == GranularPlaybackMode::MVehicle)
            {
                if (m_sampleEngine->analysisResultsAreValid())
                {
                    std::vector<AudioDescriptor>& grainDescriptionByTime = m_sampleEngine->getGrainDescriptionByTime();
 
                    float minY = 10000000.0f;
                    float maxY = 0.0f;
 
                    // Draw in phase0 (grain) boundaries
                    float numSamples = float(m_sampleEngine->getNumSamples());
                    g.setColour(Colours::cyan.withAlpha(0.3f));
                    for (auto& grainDescription : grainDescriptionByTime)
                    {
                        float xPosition = float(grainDescription.audioIndex) / numSamples;
                        drawNormalisedZoomedLine(g, {xPosition, 0.f, xPosition, 1.f}, 1);
                        if (grainDescription.frequency > maxY)
                            maxY = grainDescription.frequency;
                        if (grainDescription.frequency < minY)
                            minY = grainDescription.frequency;
                    }
 
                    // Draw in phase boundary markers (Red line)
                    bool first{true};
                    Path linePath;
                    for (auto& grainDescription : grainDescriptionByTime)
                    {
                        float xPosition = float(grainDescription.audioIndex) / numSamples;
                        float yPosition = jmap<float>(grainDescription.frequency, minY, maxY, 1.0f, 0.0f);
                        if (first)
                        {
                            linePath.startNewSubPath(xPosition, yPosition);
                        }
                        else
                        {
                            linePath.lineTo(xPosition, yPosition);
                        }
                        first = false;
                    }
                    g.setColour(Colours::red.withAlpha(0.9f));
                    drawNormalisedZoomedPath(g, linePath, 3.0f);
 
                    // Draw in a couple of general purpose indicators
                    // Once the use of these is settled, they may be renamed accordingly
 
                    // Set up a line for Indicator 1
                    float indicator1Value = 1.f - m_sampleEngine->getIndicator1();
                    Line<float> line1 = Line<float>(0.f, indicator1Value * static_cast<float>(getHeight()),
                                                    static_cast<float>(getWidth()) * 0.025f,
                                                    indicator1Value * static_cast<float>(getHeight()));
                    // Set up a line for Indicator 2
                    float indicator2Value = 1.f - m_sampleEngine->getIndicator2();
                    Line<float> line2 = Line<float>(0.f, indicator2Value * static_cast<float>(getHeight()), getWidth(),
                                                    indicator2Value * static_cast<float>(getHeight()));
                    // Draw shadows for the indicators
                    g.setColour(Colours::black.withAlpha(0.5f));
                    g.drawLine(line1, 5);
                    g.drawLine(line2, 2);
                    // Draw Indicator 1
                    g.setColour(Colours::yellow.withAlpha(1.f));
                    g.drawLine(line1, 3);
                    // Draw Indicator 2
                    g.setColour(Colours::lightcyan.withAlpha(1.f));
                    g.drawLine(line2, 1);
 
                    // Draw RPM display
                    sDisplay = "RPM: " + String(m_sampleEngine->getIndicatorRPM());
                    g.setColour(Colours::red.withAlpha(1.f));
                    g.drawFittedText(sDisplay, getWidth() / 2, 0, getWidth() / 4, getHeight() / 2,
                                     Justification::centredLeft, 1);
 
                    // Draw in wavelet display
                    if (waveletSamplesValid)
                    {
                        Path waveletPath;
                        float wxPosition = 0.75f;
                        float xIncrement = 0.125f / static_cast<float>(NUM_WAVELET_SAMPLES);
                        waveletPath.startNewSubPath(wxPosition, waveletSamples[0]);
                        for (int wSample = 1; wSample < NUM_WAVELET_SAMPLES; wSample++)
                        {
                            wxPosition += xIncrement;
                            waveletPath.lineTo(wxPosition, waveletSamples[wSample]);
                        }
                        g.setColour(Colours::white.withAlpha(1.0f));
                        drawNormalisedZoomedPath(g, waveletPath, 1.0f);
                    }
                }
            }
        }
    }
 
    float GrainDisplay::getPlayheadPosition()
    {
        if (m_grainArray == nullptr || m_sampleEngine == nullptr || m_sampleEngine->isPlaying() == false)
        {
            return 0.5f;
        }
        float playheadPos = m_grainArray[m_grainIndices[0]].playHeadStart +
                            m_grainArray[m_grainIndices[0]].grainWindow * m_grainArray[m_grainIndices[0]].length;
        playheadPos /= m_numSamples;
        return playheadPos;
    }
} // namespace krotos