backend/ogl_sys/drawing-sets/CLayerCoordinateGrid.cpp - develop - ArtemNech/simpleOpenGL

backend/ogl_sys/drawing-sets/CLayerCoordinateGrid.cpp
172 строки4 KB
Artem Nechitaylenko
Qt GUI isolated from backend except QEvent. Need fix
18 май 2026, 13:41
18 май 2026, 13:41f09d1f2
//
// Created by artem on 11.04.26.
//

//#include <glm/ext/matrix_clip_space.hpp>
#include "CLayerCoordinateGrid.h"
#include "shaderprogram.h"
#include "../../CBacking.h"
#include "../../CColorTheme.h"
#include "../CGlTransformator.h"
#include <QDebug>

CLayerCoordinateGrid::CLayerCoordinateGrid(float Z) : COglLayer(Z)
{}

CLayerCoordinateGrid::~CLayerCoordinateGrid()
= default;

bool CLayerCoordinateGrid::init()
{
    CColorTheme colors;
    auto g_colors = colors.base_colors()->grid_colors;

    greyColor = ngraph::NColor(g_colors.gray.red(), g_colors.gray.green(), g_colors.gray.blue(),
                               g_colors.gray.alpha());
    lightColor = ngraph::NColor(g_colors.highlight.red(), g_colors.highlight.green(),
                                g_colors.highlight.blue(), g_colors.highlight.alpha());


    m_vao->bind();
    m_vbo->bind();

    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(vertex_t), (void*)nullptr);

    glEnableVertexAttribArray(1);
    glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, sizeof(vertex_t), (void*)(3 * sizeof(float)));

    m_vao->unbind();
    m_vbo->unbind();

    return compile_shaders();
}

bool CLayerCoordinateGrid::compile_shaders()
{
    m_vertex_shader = R"(
        #version 330 core

        layout(location = 0) in vec3 a_position;
        layout(location = 1) in vec4 a_color;

        uniform mat4 u_screen_matrix;
        out vec4 v_color;

        void main()
        {
            v_color = a_color;
            gl_Position = u_screen_matrix * vec4(a_position, 1.0);
        }
    )";

    m_frag_shader = R"(

        #version 330 core

        in vec4 v_color;
        out vec4 FragColor;

        void main()
        {
            vec4 base_color = v_color;

            if (base_color.a < 0.05) {
                discard;
            }

            FragColor = base_color;

            // Need to test
            // FragColor = vec4(v_world_position, 1.0);
        }
    )";

    if (!m_shaderProgram->compile(m_vertex_shader, m_frag_shader))
    {
        qDebug()  <<  "Fragment shader compilation in 'CMeasureGrid' failed: ", m_shaderProgram->errors();
        m_enabled = false;
        return false;
    }

    return true;
}

void CLayerCoordinateGrid::render(CBacking *backing, const glm::mat4 & projection, const glm::mat4 & view)
{
    (void)view;
    m_backing = backing;
    m_shaderProgram->bind();
    m_vao->bind();

    m_projection = projection;


    generateVertices();

    if (!m_vertices.empty())
    {
        glDrawArrays(GL_LINES, 0, (GLsizei)m_vertices.size());
    }

}

void CLayerCoordinateGrid::generateVertices()
{
    if (!m_enabled)
    {
        return;
    }

    if (m_viewport_size == m_backing->getViewportRect().size())
    {
        return;
    }
    m_viewport_size = m_backing->getViewportRect().size();

    //ngraph::NColor highColor = {223,161,17};
    //ngraph::NColor lowColor  = {172,130,32};


    auto screen_matrix = m_projection;
    m_shaderProgram->setUniform("u_screen_matrix", screen_matrix);

    double gridSize = 20.0;

    ngraph::NLineF line_f;
    float lineWidth = 0.5;

    double wid = m_viewport_size.width();
    double height = m_viewport_size.height();

    m_vertices.clear();

    // Вертикальные линии
    int counter = 0;
    for (double x = 0; x <= wid; x += gridSize)
    {
        gridColor = counter % 5 == 0 ? lightColor : greyColor;
        //gridColor = counter % 5 == 0 ? highColor : lowColor;

        line_f = ngraph::NLineF(ngraph::NPointF(x, 0),
                                ngraph::NPointF(x, height));
        CGlTransformator::drawLine(this, line_f, gridColor, lineWidth);
        counter++;
    }

    // Горизонтальные линии
    counter = 0;
    for (double y = 0; y <= height; y += gridSize)
    {
        gridColor = counter % 5 == 0 ? lightColor : greyColor;
        //gridColor = counter % 5 == 0 ? highColor : lowColor;
        line_f = ngraph::NLineF(ngraph::NPointF(0, y),
                                ngraph::NPointF(wid, y));
        CGlTransformator::drawLine(this, line_f, gridColor, lineWidth);
        counter++;
    }
    m_vbo->bind();
    m_vbo->data(m_vertices.data(),
                m_vertices.size() * sizeof(vertex_t),
                BufferUsage::Static);
}