Neste guia, vamos demonstrar como desenhar um triângulo utilizando OpenGL dentro de uma aplicação Qt, abordando os fundamentos da renderização de GPU.

Introdução

Em cenários de renderização de alto desempenho, os recursos da CPU frequentemente são excessivamente consumidos, resultando em interfaces lentas e responsivas. OpenGL, como API gráfica padrão da indústria, permite uma aceleração significativa de hardware através da GPU, reduzindo substancialmente a carga da CPU. Este artigo utilizará como exemplo a renderização de um triângulo para demonstrar como implementar renderização de GPU multiplataforma usando QOpenGLWidget e QOpenGLFunctions do Qt.

QOpenGLFunctions

As funções OpenGL apresentam implementações diferentes entre plataformas (Windows/Linux/Mac). Por exemplo:

O Qt encapsula essas diferenças de plataforma através da classe QOpenGLFunctions. Ao herdar esta classe, os desenvolvedores podem utilizar interfaces unificadas como glClear() sem escrever código específico para cada plataforma. Isso permite usar o mesmo código em diferentes sistemas operacionais.

Para utilizar esta classe, basta fazer sua classe herdar de QOpenGLFunctions. Em combinação com QOpenGLWidget, podemos chamar initializeOpenGLFunctions() na função initializeGL() para acessar diretamente as funções OpenGL.

Carregamento no Windows (wglGetProcAddress)

No Windows, usamos wglGetProcAddress para carregar dinamicamente as funções OpenGL. Veja o código de exemplo:

• Inclusão dos headers necessários

#include <windows.h>
#include <GL/gl.h>
#include <GL/glext.h>  // Declarações de extensões OpenGL

• Definição de ponteiros de função

// Exemplo: definição do tipo de ponteiro para glClear
typedef void (APIENTRY *PFNGLCLEARPROC)(GLbitfield);
PFNGLCLEARPROC glClear;

• Carregamento das funções OpenGL

void inicializarFuncoesOpenGL() {
    // 1. Carregar função OpenGL 1.1 (fornecida por opengl32.dll)
    glClear = (PFNGLCLEARPROC)wglGetProcAddress("glClear");
    
    // 2. Verificar se o carregamento foi bem-sucedido
    if (!glClear) {
        MessageBoxA(NULL, "Falha ao carregar glClear", "Erro", MB_OK);
        exit(1);
    }
    
    // 3. Carregar outras funções de forma similar...
}

• Utilização das funções carregadas

glClear(GL_COLOR_BUFFER_BIT);  // Agora podemos chamar normalmente

Carregamento no Linux (glXGetProcAddress)

No Linux, o carregamento é feito através de glXGetProcAddress. O código correspondente é:

• Inclusão dos headers necessários

#include <GL/gl.h>
#include <GL/glx.h>  // Extensões OpenGL para X11
#include <GL/glext.h>

• Definição de ponteiros de função

// Exemplo: definição do tipo de ponteiro para glClear
typedef void (*PFNGLCLEARPROC)(GLbitfield);
PFNGLCLEARPROC glClear;

• Carregamento das funções OpenGL

void inicializarFuncoesOpenGL() {
    // 1. Carregar glClear
    glClear = (PFNGLCLEARPROC)glXGetProcAddress((const GLubyte*)"glClear");
    
    // 2. Verificar se o carregamento foi bem-sucedido
    if (!glClear) {
        fprintf(stderr, "Falha ao carregar glClear\n");
        exit(1);
    }
    
    // 3. Carregar outras funções de forma similar...
}

• Utilização das funções carregadas

glClear(GL_COLOR_BUFFER_BIT);  // Agora podemos chamar normalmente

QOpenGLWidget

QOpenGLWidget é uma classe widget fornecida pelo Qt para incorporar conteúdo renderizado por OpenGL em aplicações Qt. Herdando de QWidget, gerencia um contexto OpenGL (como wglMakeCurrent/wglDoneCurrent no Windows) e buffers de quadro, proporcionando integração perfeita com o sistema de janelas do Qt.

Podemos criar nossa própria janela herdando QOpenGLWidget e sobrescrever três funções para lidar com operações OpenGL:

initializeGL

Inicializa recursos ou estados relacionados ao OpenGL. Esta função é chamada antes da primeira invocação de resizeGL ou paintGL.

paintGL

Renderiza a cena OpenGL, similar a QWidget::paintEvent, sendo chamada quando a janela precisa ser atualizada.

resizeGL

Ajusta o tamanho do Viewport OpenGL ou atualiza projeções, sendo chamado quando a janela é redimensionada.

Código Completo

Arquivo de cabeçalho (OpenGLWidget.h)

#pragma once

#include <QOpenGLBuffer>
#include <QOpenGLWidget>
#include <QOpenGLShaderProgram>
#include <QOpenGLFunctions>

class RenderizadorOpenGL : public QOpenGLWidget, protected QOpenGLFunctions
{
    Q_OBJECT

public:
    explicit RenderizadorOpenGL(QWidget *pai = nullptr);
    ~RenderizadorOpenGL() override;

private:
    void inicializarShaders();

private:
    void initializeGL() override;
    void paintGL() override;
    void resizeGL(int largura, int altura) override;
    
private:
    QOpenGLShaderProgram programaShader;
    QOpenGLBuffer vbo;
};

Arquivo de implementação (OpenGLWidget.cpp)

#include "OpenGLWidget.h"

// Coordenadas dos vértices do triângulo
static const GLfloat verticesTriangulo[] = {
    // Coordenadas x, y, z
    -0.5f, -0.5f, 0.0f,
     0.5f, -0.5f, 0.0f,
     0.0f,  0.5f, 0.0f,
};

// Código do shader de vértice
constexpr char SHADER_VERTICE[] = R"(
attribute vec3 posicaoVertice; 
void main(void)
{
    gl_Position = vec4(posicaoVertice, 1.0);
}
)";

// Código do shader de fragmento
constexpr char SHADER_FRAGMENTO[] = R"(
void main(void) 
{ 
    gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); 
}
)";

RenderizadorOpenGL::RenderizadorOpenGL(QWidget *pai)
    : QOpenGLWidget(pai)
{}

RenderizadorOpenGL::~RenderizadorOpenGL()
{}

void RenderizadorOpenGL::initializeGL()
{
    initializeOpenGLFunctions();
    glDisable(GL_DEPTH_TEST);

    // Criar e vincular o VBO
    vbo.create();
    vbo.bind();
    vbo.allocate(verticesTriangulo, sizeof(verticesTriangulo));

    // Inicializar shaders
    inicializarShaders();

    // Limpar a tela com cor preta
    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
    glClear(GL_COLOR_BUFFER_BIT);
}

void RenderizadorOpenGL::paintGL()
{
    programaShader.bind();
    glDrawArrays(GL_TRIANGLES, 0, 3);
    programaShader.release();
}

void RenderizadorOpenGL::resizeGL(int largura, int altura)
{
    glViewport(0, 0, largura, altura);
    update();
}

void RenderizadorOpenGL::inicializarShaders()
{
    // Compilar shader de vértice
    QOpenGLShader shaderVertice(QOpenGLShader::Vertex);
    if (!shaderVertice.compileSourceCode(SHADER_VERTICE))
    {
        qDebug() << "Falha na compilação do shader de vértice. Erro: " << shaderVertice.log();
        return;
    }

    // Compilar shader de fragmento
    QOpenGLShader shaderFragmento(QOpenGLShader::Fragment);
    if (!shaderFragmento.compileSourceCode(SHADER_FRAGMENTO))
    {
        qDebug() << "Falha na compilação do shader de fragmento. Erro: " << shaderFragmento.log();
        return;
    }

    // Adicionar shaders ao programa
    programaShader.addShader(&shaderVertice);
    programaShader.addShader(&shaderFragmento);

    // Linkar o programa de shader
    programaShader.link();
    programaShader.bind();

    // Configurar atributo de vértice
    programaShader.setAttributeBuffer("posicaoVertice", GL_FLOAT, 0, 3, 3 * sizeof(float));
    programaShader.enableAttributeArray("posicaoVertice");
}