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) {
    m_context.setOpenGLVersionRequired(OpenGLContext::OpenGLVersion::openGL3_2);
    m_context.setRenderer(this);
    m_context.setContinuousRepainting(false);
    m_context.setComponentPaintingEnabled(true);
    m_context.attachTo(*this);
    auto fps = Config::getInstance()->getFps();
    startTimerHz(Config::getInstance()->getFps());
    std::srand(unsigned(time(nullptr)));
    pickRandomText = (std::rand() % RANDOM_TEXT_COUNT);
    m_ticks = 0;
    // is something that
    m_time_needed = roundToInt(4000 / (1000 / fps));
    m_time_needed_startup = roundToInt(1000 / (1000 / fps));
}

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::handleAsyncUpdate() {

}

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();
        }
    }
}

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 = jmap(Decibels::gainToDecibels(instance->audioBuffer->leftPeak, -80.0f), -80.0f, 6.0f, -1.0f,
                            1.0f);
    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 = jmap(Decibels::gainToDecibels(instance->audioBuffer->rightPeak, -80.0f), -80.0f, 6.0f, -1.0f,
                             1.0f);
    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.8 && value < 0.9) {
        color = theme->getColour(ThemeColour::warning);
    }
    if (value > 0.9) {
        color = theme->getColour(ThemeColour::clip);
    }
    shaderProgram->setUniform("color", color.getFloatRed(), color.getFloatGreen(), color.getFloatBlue(),
                              color.getFloatAlpha());
}