backend/ogl_sys/QOpenGLRenderer.cpp - devOpt - ArtemNech/simpleOpenGL

backend/ogl_sys/QOpenGLRenderer.cpp
153 строки4 KB
Artem Nechitaylenko
Тупиковая ветка. Оптимизация только от контекста
31 май 2026, 15:27
31 май 2026, 15:278136c99
//
// Created by artem on 25.10.25.
//
#include "drawing-sets/glad.h"

#include "QOpenGLRenderer.h"
#include <QPainter>
#include <glm/ext/matrix_clip_space.hpp>
#include <glm/ext/matrix_transform.hpp>
#include "../CBacking.h"
#include "../CColorTheme.h"
#include "drawing-sets/COglTextManager.h"
#include "drawing-sets/COglImageManager.h"
#include "drawing-sets/CLayerObjects.h"
#include "drawing-sets/CLayerCoordinateGrid.h"
#include "drawing-sets/CLayerConnectionsLine.h"
#include "drawing-sets/CLayerPostprocess.h"
#include "drawing-sets/CLayerDrag.h"
#include "drawing-sets/CRenderer.h"


COglTextManager     * ogl_text_manager{nullptr};

using namespace ngraph;


QOpenGLRenderer::QOpenGLRenderer()
    : m_backing(new CBacking())
{}


QOpenGLRenderer::~QOpenGLRenderer()
{
    delete ogl_text_manager;
    delete m_image_manager;
    delete m_linesLayer;
    delete m_coord_grid_layer;
    delete m_objects_layer;
    delete m_layer_drag;
    delete m_postProcessLayer;
    delete m_backing;
    delete m_renderLayer;
}

void QOpenGLRenderer::initialize()
{
    initializeOpenGLFunctions();
    CColorTheme colors;

    auto bkg_col = colors.base_colors()->background_color;

    col[0] = bkg_col.redF();
    col[1] = bkg_col.greenF();
    col[2] = bkg_col.blueF();
    col[3] = bkg_col.alphaF();

    glClearColor(col[0], col[1], col[2], col[3]);

    glEnable(GL_BLEND);
    glEnable(GL_DEPTH_TEST);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    //glDisable(GL_FOG);

    if (!gladLoadGL())
    {
        qDebug() << "GLAD initialization failed!";
        return;
    }

    ogl_text_manager = new COglTextManager();
    ogl_text_manager->init_font();
    m_image_manager = new COglImageManager;

    m_coord_grid_layer  = new CLayerCoordinateGrid(0.5);
    m_objects_layer     = new CLayerObjects(m_image_manager, ogl_text_manager, 0.8);
    m_layer_drag        = new CLayerDrag(m_image_manager, 1.0f);
    m_linesLayer        = new CLayerConnectionsLine(0.7);


    m_layers[E_COORD_GRID]  = m_coord_grid_layer;
    m_layers[E_OBJECTS]     = m_objects_layer;
    m_layers[E_DRAG]        = m_layer_drag;
    m_layers[E_CONNECTIONS] = m_linesLayer;

    m_renderLayer = new CRenderer();

    // с эффектами как-нибудь потом
    m_postProcessLayer = new CLayerPostprocess();
    m_postProcessLayer->init();

}

void QOpenGLRenderer::resize(int w, int h)
{
    glViewport(0, 0, w, h);
    m_size.setWidth(w);
    m_size.setHeight(h);
    NRectF rect({0,0}, m_size.width(), m_size.height());
    m_backing->setViewportRect(rect);
}

void QOpenGLRenderer::renderDiagram(GLuint defBuff)
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glDepthFunc(GL_LEQUAL);

    if (!m_backing->diagram())
    {
        return;
    }

    while (glGetError() != GL_NO_ERROR) {}

    if (m_postProcessing )
    {
        m_postProcessLayer->createFBO(m_size.width(), m_size.height());
        glBindFramebuffer(GL_FRAMEBUFFER, m_postProcessLayer->fbo());
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    }


    glm::mat4 view_mat = m_backing->getViewTransform().toGlmMatrix();
    glm::mat4 projection = glm::ortho(0.0f, (float)m_size.width(), (float)m_size.height(), 0.0f, -100.0f, 100.0f);

    // if the layer is enabled, but not visible - error with shaders is auto disabling
    // just generating vertices
    for (auto &pair : m_layers)
    {
        if (pair.second->is_enabled())
        {
            pair.second->collectVertices(m_backing);
            m_renderLayer->addBin(pair.second->vertexBin());
        }
    }
    // renderer
    m_renderLayer->render(projection, view_mat);

    if (m_postProcessing)
    {
        // saveFBOToFile(m_postProcessLayer->fbo(), m_size.width(), m_size.height(), "fbo_dump.png");

        glBindFramebuffer(GL_FRAMEBUFFER, defBuff);
        glViewport(0, 0, m_size.width(), m_size.height());
        glClear(GL_COLOR_BUFFER_BIT);

        m_postProcessLayer->collectVertices(m_backing, projection, view_mat);
    }
}

void QOpenGLRenderer::takeController(CInteractionController *controller)
{
    m_backing->setInteractionController(controller);
}