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

backend/ogl_sys/QOpenGLRenderer.cpp
178 строк5 KB
Artem Nechitaylenko
Необходимо поддерживать масштабирование KDE. Прокинул реальный размер QOpenGLWidget в backend, надо прикрутить к физике
28 июл 2026, 08:27
28 июл 2026, 08:27e16a021
//
// 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"


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

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_postProcessLayer = new CLayerPostprocess();
    m_postProcessLayer->init();
    //m_layer_postProcess = new CPostProcessLayer(1.1f);
    //m_layers[E_POST_PROC]   = m_layer_postProcess;
    //auto scanLine = new CScanlinesEffect();
    //m_layer_postProcess->addEffect(scanLine);

    for (auto &pair : m_layers)
    {
        pair.second->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 saveFBOToFile(GLuint fboId, int width, int height, const QString& filename)
{
    if (width <= 0 || height <= 0) return;

    glBindFramebuffer(GL_READ_FRAMEBUFFER, fboId);

    std::vector<GLubyte> pixels(width * height * 4);

    glPixelStorei(GL_PACK_ALIGNMENT, 1);
    glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels.data());
    glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);

    QImage image(pixels.data(), width, height, QImage::Format_RGBA8888);

    QImage flippedImage = image.flipped(Qt::Vertical);

    if (!flippedImage.save(filename))
    {
        qDebug() << "[FBO Debug] Failed to save image to:" << filename;
    }
}

void QOpenGLRenderer::renderDiagram(GLuint defBuff, const ngraph::NSize &physicSize)
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glDepthFunc(GL_LEQUAL);

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


    if (m_postProcessing )
    {
        m_postProcessLayer->createFBO(physicSize.width(), physicSize.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
    for (auto &pair : m_layers)
    {
        if (pair.second->is_enabled())
        {
            pair.second->render(m_backing, 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, physicSize.width(), physicSize.height());

        glClear(GL_COLOR_BUFFER_BIT);

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

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