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

backend/ogl_sys/drawing-sets/CLayerDrag.cpp
223 строки6 KB
Artem Nechitaylenko
All objects are works and draggable
20 май 2026, 09:40
20 май 2026, 09:40bf16523
//
// Created by artem on 17.04.26.
//
#include "shaderprogram.h"
#include <QDebug>
#include "CLayerDrag.h"
#include "../../CBacking.h"
#include "../CGlTransformator.h"
#include "COglImageManager.h"
#include "../../diagram/ndrag.h"

CLayerDrag::CLayerDrag(COglImageManager * imgPainter, float Z)
    : COglLayer(Z)
    , m_imagesPainter(imgPainter)
{
    m_shaders[E_GEOM] = new ShaderProgram();
    m_shaders[E_PIC] = new ShaderProgram();
}

CLayerDrag::~CLayerDrag()
{
    delete m_shaders[E_GEOM];
    delete m_shaders[E_PIC];
}

void CLayerDrag::init_shaders()
{
    //------------------------------------------------------------------------------------------------------------------
    // линии с прямоугольниками без градиентов
    //------------------------------------------------------------------------------------------------------------------
    m_shaders_programs[E_GEOM].first = R"(
        #version 330 core

        layout(location = 0) in vec3 in_position;
        layout(location = 1) in vec4 in_color;

        uniform mat4  model_projection;

        out vec4 v_color;

        void main()
        {
            gl_Position = model_projection * vec4(in_position, 1.0);
            v_color = in_color;
        }
    )";
    m_shaders_programs[E_GEOM].second = R"(
        #version 330 core
        in vec4 v_color;

        out vec4 out_color;

        void main()
        {
            out_color = v_color;

            if (out_color.a < 0.01) {
                discard;
            }
        }
    )";
    //------------------------------------------------------------------------------------------------------------------
    // картинки
    //------------------------------------------------------------------------------------------------------------------
    m_shaders_programs[E_PIC].first = R"(
        #version 330 core

        layout(location = 0) in vec3 in_position;
        layout(location = 1) in vec4 in_color;
        layout(location = 2) in vec2 tex_coord;

        uniform mat4 model_projection;

        out vec4 v_color;
        out vec2 v_texCoord;

        void main()
        {
            v_color = in_color;
            v_texCoord = tex_coord;
            gl_Position = model_projection * vec4(in_position, 1.0);
        }
    )";
    m_shaders_programs[E_PIC].second = R"(
        #version 330 core

        in vec4 v_color;
        in vec2 v_texCoord;

        uniform sampler2D textureSampler;

        out vec4 out_color;

        void main()
        {
            vec4 texColor = texture(textureSampler, v_texCoord);
            out_color = texColor;
            if (out_color.a < 0.01) discard;
        }
    )";
}

bool CLayerDrag::init()
{
    if (!compile_shaders())
    {
        m_enabled = false;
        return false;
    }

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

    glEnableVertexAttribArray(2);
    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(vertex_t), (void*)(7 * sizeof(float)));

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

    return true;
}

bool CLayerDrag::compile_shaders()
{
    init_shaders();

    for (int i = 0; i < E_COUNT; i++)
    {
        auto t = (Shaders)i;
        if (!m_shaders[i]->compile(m_shaders_programs[t].first, m_shaders_programs[t].second))
        {
            qDebug() << "Fragment shader in 'CLadderGridSet' compilation failed: " << m_shaders[i]->errors();
            m_enabled = false;
            return false;
        }
    }

    return true;
}

void CLayerDrag::generateVertices()
{
    const NDrag * drag_objects = m_backing->draggingObjects();
    if (!drag_objects || drag_objects->objectsToDraw().empty())
    {
        return;
    }

    for (auto & item : drag_objects->objectsToDraw())
    {
        auto color = item.fillColor;
        color.setAlpha(127);
        CGlTransformator::drawRect(this, item.rect, color);
    }

    /*float old_z = m_z;
    m_z = 1.2;*/
    m_imagesPainter->explode_image(this, drag_objects->baseDragImage());
    //m_z = old_z;
}

void printVertex(const vertex_t& v)
{
    qDebug() << "pos: (" << v.x << "," << v.y << "," << v.z << ")";
    qDebug() << "color: (" << v.r << "," << v.g << "," << v.b << "," << v.a << ")";
    qDebug() << "tex: (" << v.tx << "," << v.ty << ")";
}

void CLayerDrag::render(CBacking *backing, const glm::mat4 & projection, const glm::mat4 & view)
{
    if (!backing) return;
    m_backing = backing;

    m_batches.clear();
    m_vertices.clear();

    generateVertices();

    if (m_batches.empty())
    {
        return;
    }

    auto base_projection = projection * view;

    m_vao->bind();
    m_vbo->bind();
    m_vbo->data(m_vertices.data(),
                static_cast<int>(m_vertices.size() * sizeof(vertex_t)),
                BufferUsage::Dynamic);

    for (auto & batch : m_batches)
    {
        Shaders type = batch.useTexture ? E_PIC : E_GEOM;
        ShaderProgram * shader = m_shaders[type];
        shader->bind();
        shader->setUniform("model_projection", base_projection);

        if (batch.useTexture)
        {
            shader->setUniform("textureSampler", 0);
            glActiveTexture(GL_TEXTURE0);
            glBindTexture(GL_TEXTURE_2D, batch.textureId);

            /*uint32_t start = batch.vertexOffset;
            for (uint32_t vPos = start; vPos < start+batch.vertexCount; vPos++)
            {
                auto &ver = m_vertices.at(vPos);
                printVertex(ver);
            }
            glm::vec4 testPos = base_projection * glm::vec4(242, 159, 1.2, 1.0);
            qDebug() << "Transformed position:" << testPos.x << testPos.y << testPos.z << testPos.w;*/
        }

        glDrawArrays(batch.primitive, batch.vertexOffset, batch.vertexCount);
    }
}