Qt5操作OpenGL(核心模式)



  • main.cpp

    #include <QApplication>
    #include <QDebug>
    #include "canvas.h"
    
    int main(int argc, char *argv[])
    {
        QApplication a(argc, argv);
    
        QSurfaceFormat glFormat;
        glFormat.setVersion(3, 3);                           //  设置OpenGL版本
        glFormat.setProfile(QSurfaceFormat::CoreProfile);    // 设置使用核心模式
        QSurfaceFormat::setDefaultFormat(glFormat);
    
        Canvas *c = new Canvas();
        c->show();
    
        return a.exec();
    }
    

    Canvas.h

    #ifndef CANVAS_H
    #define CANVAS_H
    
    #include <QWidget>
    #include <QOpenGLWidget>
    #include <QOpenGLExtraFunctions>
    
    class Canvas : public QOpenGLWidget,protected QOpenGLExtraFunctions
    {
        Q_OBJECT
    public:
        explicit Canvas();
    
    signals:
    
    public slots:
    
    private:
    
    protected:
        virtual void initializeGL();
        virtual void resizeGL(int w, int h);
        virtual void paintGL();
    
    private:
        GLuint shaderProgram;
    };
    
    #endif
    

    Canvas.cpp

    #include "canvas.h"
    #include <QtDebug>
    #include <QtOpenGL>
    
    // 以下为测试代码,不推荐这么写
    // =================================
    GLuint VBO, VAO;
    const char *vertexShaderSource =
            "#version 330 core\n"
            "layout(location = 0) in vec3 aPos;\n"
            "void main(){\n"
            "  gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);\n"
            "}\n\0";
    const char *fragmentShaderSource =
            "#version 330 core\n"
            "out vec4 FragColor;\n"
            "void main(){\n"
            "   FragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);\n"
            "}\n\0";
    // =================================
    
    Canvas::Canvas()
    {
    
    }
    
    void Canvas::initializeGL()
    {
        //着色器部分
        this->initializeOpenGLFunctions();
        int vertexShader = glCreateShader(GL_VERTEX_SHADER);
        glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
        glCompileShader(vertexShader);
    
        int success;
        char infoLog[512];
        glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
        if (!success)
        {
            glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
            qDebug() << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << endl;
        }
    
        int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    
        glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
        glCompileShader(fragmentShader);
    
        glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
        if (!success)
        {
            glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
            qDebug() << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" << infoLog << endl;
        }
        shaderProgram = glCreateProgram();
        glAttachShader(shaderProgram, vertexShader);
        glAttachShader(shaderProgram, fragmentShader);
        glLinkProgram(shaderProgram);
    
        glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
        if (!success) {
            glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog);
            qDebug() << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << endl;
        }
        glDeleteShader(vertexShader);
        glDeleteShader(fragmentShader);
    
        GLfloat vertices[] = {
            -0.5f, -0.5f, 0.0f,
            0.5f, -0.5f, 0.0f,
            0.0f,  0.5f, 0.0f
        };
    
        glGenVertexArrays(1, &VAO);
        glGenBuffers(1, &VBO);
        glBindVertexArray(VAO);
        glBindBuffer(GL_ARRAY_BUFFER, VBO);
    
        glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), (void*)0);
        glEnableVertexAttribArray(0);
    
        glBindBuffer(GL_ARRAY_BUFFER, 0);
        glBindVertexArray(0);
    }
    
    void Canvas::resizeGL(int width, int height)
    {
        glViewport(0, 0, width, height);
    }
    
    void Canvas::paintGL()
    {
        glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);
    
        glUseProgram(shaderProgram);
        glBindVertexArray(VAO);
        glDrawArrays(GL_TRIANGLES, 0, 3);
        glUseProgram(0);
    }
    

Log in to reply