reVeno/Source/Veno/GUI/Components/LCD/Waveforms.cpp

//
// Created by versustune on 11.06.20.
//

#include "Waveforms.h"
#include <utility>
#include "../../../Core/Config.h"
#include "../../../Utils.h"
#include "../../../VenoInstance.h"
#include "../../../Fonts/Fonts.h"

Waveforms::Waveforms (const std::string& processId) : BaseComponent(processId)
{
    setMouseCursor(MouseCursor::PointingHandCursor);
    m_context.setOpenGLVersionRequired(OpenGLContext::OpenGLVersion::openGL3_2);
    m_context.setRenderer(this);
    m_context.setContinuousRepainting(false);
    m_context.setComponentPaintingEnabled(true);
    m_context.attachTo(*this);
    setFps();
    std::srand(unsigned(time(nullptr)));
    pickRandomText = (std::rand() % RANDOM_TEXT_COUNT);
    m_ticks = 0;
}

Waveforms::~Waveforms ()
{
    stopTimer();
    shaderProgram.reset();
    m_context.detach();
}

void Waveforms::newOpenGLContextCreated ()
{
    compileOpenGLShaderProgram();
}

void Waveforms::openGLContextClosing ()
{

}

void Waveforms::renderOpenGL ()
{
    if (!isShowing() || shaderProgram == nullptr || !shaderProgram->getLastError().isEmpty())
    {
        return;
    }
    auto theme = Config::getInstance()->getCurrentTheme();
    if (theme == nullptr)
    {
        return;
    }
    glViewport(0, 0, getWidth(), getHeight());
    OpenGLHelpers::clear(theme->getColour(ThemeColour::lcd_bg));
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    shaderProgram->use();
    auto color = theme->getColour(ThemeColour::lcd);
    shaderProgram->setUniform("color", color.getFloatRed(), color.getFloatGreen(), color.getFloatBlue(),
                              color.getFloatAlpha());
    if (m_isWelcome || m_isStarting || m_isChangingData)
    {
        return;
    }
    switch (m_mode)
    {
        case 1:
            drawAudioOutput();
            break;
        case 2:
            drawWaveTable();
            break;
        case 3:
            drawSpectrum();
            break;
        default:
            drawPeakMeter();
    }
}

void Waveforms::compileOpenGLShaderProgram ()
{
    std::unique_ptr<OpenGLShaderProgram> shaderProgramAttempt
            = std::make_unique<OpenGLShaderProgram>(m_context);
    if (shaderProgramAttempt->addVertexShader({BinaryData::WaveForm_vertex_glsl})
        && shaderProgramAttempt->addFragmentShader({BinaryData::WaveForm_fragment_glsl})
        && shaderProgramAttempt->link())
    {
        shaderProgram = std::move(shaderProgramAttempt);
    }
}

void Waveforms::mouseDown (const MouseEvent& e)
{
    if (!m_enableModeToggle)
    {
        return;
    }
    m_mode++;
    if (m_mode > 3)
    {
        m_mode = 0;
    }
}

void Waveforms::mouseDrag (const MouseEvent& e)
{
    //do nothing... you faggot
}

void Waveforms::timerCallback ()
{
    if (m_isWelcome || m_isStarting || m_isChangingData || needToClear)
    {
        repaint();
    }
    else
    {
        if (m_context.isAttached())
        {
            m_context.triggerRepaint();
        }
    }
    setFps();
}

void Waveforms::drawWaveTable ()
{
    // this will draw the current selected oscillator :D
}

void Waveforms::drawAudioOutput ()
{
    // draw audio from the oscillators
    auto instance = VenoInstance::getInstance(BaseComponent::m_processId);
    auto buffer = instance->audioBuffer->getBuffer();
    glBegin(GL_LINE_STRIP);
    float posX = -1;
    float inc = 2.0f / buffer.size();
    for (float i : buffer)
    {
        glVertex2f(posX, i);
        posX += inc;
    }
    glEnd();
}

void Waveforms::drawPeakMeter ()
{
    auto theme = Config::getInstance()->getCurrentTheme();
    if (theme == nullptr)
    {
        return;
    }
    auto instance = VenoInstance::getInstance(BaseComponent::m_processId);
    instance->audioBuffer->calcPeak();
    // draw peak signal
    auto leftChannel = getdBForChannel(instance->audioBuffer->leftPeak);
    selectColourByPeak(leftChannel);
    glBegin(GL_TRIANGLES);
    glVertex2f(-0.9f, leftChannel);
    glVertex2f(-0.9f, -1.0f);
    glVertex2f(-0.01f, -1.0f);
    glVertex2f(-0.9f, leftChannel);
    glVertex2f(-0.01f, leftChannel);
    glVertex2f(-0.01f, -1.0f);
    glEnd();
    auto rightChannel = getdBForChannel(instance->audioBuffer->rightPeak);
    selectColourByPeak(rightChannel);
    glBegin(GL_TRIANGLES);
    glVertex2f(0.9f, rightChannel);
    glVertex2f(0.9f, -1.0f);
    glVertex2f(0.01f, -1.0f);
    glVertex2f(0.9f, rightChannel);
    glVertex2f(0.01f, rightChannel);
    glVertex2f(0.01f, -1.0f);
    glEnd();
}

void Waveforms::paint (Graphics& g)
{
    std::shared_ptr<Theme> theme = Config::getInstance()->getCurrentTheme();
    auto accent = theme->getColour(ThemeColour::lcd);
    g.setColour(accent);
    g.setFont(*VenoFonts::getLCD());
    VeNo::Utils::setFontSize(16.0f, g);
    if (m_isWelcome)
    {
        drawWelcome(g, getWidth(), getHeight(), 0, 0);
        m_ticks++;
        if (m_ticks > m_time_needed_startup)
        {
            m_isWelcome = false;
            m_ticks = 0;
            needToClear = true;
        }
    }
    else if (m_isStarting)
    {
        g.drawText(m_warmUpText[pickRandomText], 0, 0, getWidth(), getHeight(),
                   Justification::centred, true);
        m_ticks++;
        if (m_ticks > m_time_needed_startup)
        {
            m_isStarting = false;
            m_ticks = 0;
            needToClear = true;
        }
    }
    else if (m_isChangingData)
    {
        drawChangedParameter(g, getWidth(), getHeight(), 0, 0);
        m_ticks++;
        if (m_ticks > m_time_needed)
        {
            m_isChangingData = false;
            m_ticks = 0;
            needToClear = true;
        }
    }
    else
    {
        g.resetToDefaultState();
        needToClear = false;
    }
}

void Waveforms::drawChangedParameter (Graphics& g, int w, int h, int x, int y) const
{
    int halfHeight = h / 2;
    float font = VeNo::Utils::setFontSize(12, g);
    g.drawText(changingParameter, x, y + halfHeight - font, w, font, Justification::centred, true);
    g.drawText(std::to_string(changedValue), x, y + halfHeight + 4, w, font, Justification::centred,
               true);
}

void Waveforms::drawWelcome (Graphics& g, int w, int h, int x, int y)
{
    float font = VeNo::Utils::setFontSize(12, g);
    int halfHeight = h / 2;
    g.drawText(m_readyText, x, y + halfHeight - font, w, font, Justification::centred, true);
    g.drawText(SystemStats::getLogonName(), x, y + halfHeight + 4, w, font, Justification::centred,
               true);
}

void Waveforms::drawSpectrum ()
{
}

void Waveforms::selectColourByPeak (float value)
{
    auto theme = Config::getInstance()->getCurrentTheme();
    if (theme == nullptr)
    {
        return;
    }
    auto color = theme->getColour(ThemeColour::lcd);
    if (value > 0.9)
    {
        color = theme->getColour(ThemeColour::clip);
    }
    else if (value > 0.8)
    {
        color = theme->getColour(ThemeColour::warning);
    }
    shaderProgram->setUniform("color", color.getFloatRed(), color.getFloatGreen(), color.getFloatBlue(),
                              color.getFloatAlpha());
}

float Waveforms::getdBForChannel (float value)
{
    float v = VeNo::Utils::clamp(Decibels::gainToDecibels(value, -60.0f), -60.0f, 6.0f);
    return jmap(v, -60.0f, 6.0f, -1.0f,
                1.0f);
}

void Waveforms::setFps ()
{
    if(m_currentFps != Config::getInstance()->getFps()) {
        m_currentFps = Config::getInstance()->getFps();
        // is something that
        m_time_needed = roundToInt(4000 / (1000 / m_currentFps));
        m_time_needed_startup = roundToInt(1000 / (1000 / m_currentFps));
        stopTimer();
        startTimer(m_currentFps);
    }
}