Qt OPenGL 入门教程之六基于QOpenGLWidget 3D立方体纹理贴图

亦凉 2023-06-25 10:11 11阅读 0赞

纹理贴图是 opengl 极为重要的一个知识，相关知识点在此暂时不做介绍，这里只给出一个可运行的示例，

我对demo进行了一定的改动，其中在构造函数定义了一个PROGRAM\_2D的宏，定义的时候为一个2个面的纹理贴图，注释掉该宏则会实现一个3d的贴图。同时给我们的例子添加键盘和鼠标动作，详细可以自行运行体验。

相比于前面几节，本节我们添加resources资源项，并添加图片。

![20191228001513880.png][]

具体代码如下：

//myopenglwidget.h
    #ifndef MYOPENGLWIDGET_H
    #define MYOPENGLWIDGET_H
    
    #include <QOpenGLWidget>
    #include <QOpenGLFunctions>
    #include <QOpenGLBuffer>
    #include <QMouseEvent>
    #include <QKeyEvent>
    
    class QOpenGLShaderProgram;
    class QOpenGLTexture;
    
    class MyOpenGLWidget : public QOpenGLWidget, protected QOpenGLFunctions
    {
        Q_OBJECT
    
    public:
        explicit MyOpenGLWidget(QWidget *parent = 0);
        ~MyOpenGLWidget();
        QSize minimumSizeHint() const override;
        void keyPressEvent(QKeyEvent *event) override;
        QSize sizeHint() const override;
        void rotateBy(int xAngle, int yAngle, int zAngle);
        void setClearColor(const QColor &color);
    signals:
        void clicked();
    
    protected:
        void initializeGL() override;
        void paintGL() override;
        void resizeGL(int width, int height) override;
        void mousePressEvent(QMouseEvent *event) override;
        void mouseMoveEvent(QMouseEvent *event) override;
        void mouseReleaseEvent(QMouseEvent *event) override;
    
    private:        
        void makeObject();
        void make2DObject();
        QColor clearColor;
        QPoint lastPos;
        GLfloat translate, xRot, yRot, zRot;
        void printContextInformation();
        QOpenGLShaderProgram *program;
        QOpenGLBuffer vbo;
        QOpenGLTexture *textures[6];
    };
    
    #endif // MYOPENGLWIDGET_H
    
    //myopenglwidget.cpp
    #include "myopenglwidget.h"
    #include <QOpenGLShaderProgram>
    #include <QOpenGLTexture>
    #include <QOpenGLExtraFunctions>
    MyOpenGLWidget::MyOpenGLWidget(QWidget *parent)
        : QOpenGLWidget(parent),
          translate(-3),
          xRot(0),
          yRot(0),
          zRot(0)
    {
        #define PROGRAM_2D  1; //可将该行注释掉观察程序的变化
        memset(textures, 0, sizeof(textures));
    }
    
    MyOpenGLWidget::~MyOpenGLWidget()
    {
        makeCurrent();
        vbo.destroy();
        for (int i = 0; i < 6; ++i)
            delete textures[i];
        delete program;
        doneCurrent();
    }
    
    QSize MyOpenGLWidget::minimumSizeHint() const
    {
        return QSize(200, 200);
    }
    
    void MyOpenGLWidget::keyPressEvent(QKeyEvent *event)
    {
        switch (event->key()) {
        case Qt::Key_Up:
            xRot += 10;
            break;
        case Qt::Key_Left:
            yRot += 10;
            break;
        case Qt::Key_Right:
            zRot += 10;
            break;
        case Qt::Key_Down:
            translate -= 1;
            break;
        case Qt::Key_Space:
            translate += 1;
            break;
        default:
            break;
        }
        update();
        QOpenGLWidget::keyPressEvent(event);
    }
    
    QSize MyOpenGLWidget::sizeHint() const
    {
         return QSize(500, 500);
    }
    
    void MyOpenGLWidget::rotateBy(int xAngle, int yAngle, int zAngle)
    {
        xRot += xAngle;
        yRot += yAngle;
        zRot += zAngle;
        update();
    }
    
    void MyOpenGLWidget::setClearColor(const QColor &color)
    {
        clearColor = color;
        update();
    }
    
    
    void MyOpenGLWidget::initializeGL()
    {
    
        // 为当前环境初始化OpenGL函数
        initializeOpenGLFunctions();
        printContextInformation();
    #ifdef PROGRAM_2D
        for (int i = 0; i < 2; ++i)
            textures[i] = new QOpenGLTexture(QImage(QString("../myopengl/side%1.png")
                                                   .arg(i + 1)).mirrored());
    #else
        makeObject();
    #endif
        glEnable(GL_DEPTH_TEST);
        glEnable(GL_CULL_FACE);
    
    #define PROGRAM_VERTEX_ATTRIBUTE 0
    #define PROGRAM_TEXCOORD_ATTRIBUTE 1
    
        // 创建顶点着色器
        QOpenGLShader *vshader = new QOpenGLShader(QOpenGLShader::Vertex, this);
        const char *vsrc =
                "attribute highp vec4 vPosition;           \n"
                "attribute mediump vec4 vTexCoord;         \n"
                "varying mediump vec4 texCoord;            \n"
                "uniform mediump mat4 matrix;              \n"
                "void main() {                             \n"
                "   texCoord = vTexCoord;                  \n"
                "   gl_Position = matrix * vPosition;      \n"
                "}                                         \n";
        vshader->compileSourceCode(vsrc);
        // 创建片段着色器
        QOpenGLShader *fshader = new QOpenGLShader(QOpenGLShader::Fragment, this);
        const char *fsrc =
                "uniform sampler2D tex;                     \n"
                "varying mediump vec4 texCoord;             \n"
                "void main() {                              \n"
                "   gl_FragColor = texture2D(tex, texCoord.st); \n"
                "}                                          \n";
        fshader->compileSourceCode(fsrc);
    //    vshader->compileSourceFile(":/simple.vert");
    //    fshader->compileSourceFile(":/simple.frag");
    
    
        // 创建着色器程序
        program = new QOpenGLShaderProgram;
    //    program->addShaderFromSourceFile(QOpenGLShader::Vertex, ":/vert.glsl");
    //    program->addShaderFromSourceFile(QOpenGLShader::Fragment, ":/frag.glsl");
    
        program->addShader(vshader);
        program->addShader(fshader);
        program->bindAttributeLocation("vPosition", PROGRAM_VERTEX_ATTRIBUTE);
        program->bindAttributeLocation("vTexCoord", PROGRAM_TEXCOORD_ATTRIBUTE);
    
        program->link();
        program->bind();
        program->setUniformValue("texture", 0);
    
    }
    
    void MyOpenGLWidget::resizeGL(int width , int height)
    {
        int side = qMin(width, height);
        glViewport((width - side) / 2, (height - side) / 2, side, side);
    }
    
    
    void MyOpenGLWidget::paintGL()
    {
        int w = width();
        int h = height();
        int side = qMin(w, h);
        glViewport((w - side) / 2, (h - side) / 2, side, side);
    
        glClearColor(clearColor.redF(), clearColor.greenF(),
                     clearColor.blueF(), clearColor.alphaF());
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
    #ifdef PROGRAM_2D
        // 顶点位置
        GLfloat vertices[2][4][3] = {
            { {-0.8f, 0.8f, 0.8f}, {-0.8f, -0.8f, 0.8f}, {0.8f, -0.8f, 0.8f}, {0.8f, 0.8f, 0.8f} },
            { {0.8f, 0.8f, 0.8f}, {0.8f, -0.8f, 0.8f}, {0.8f, -0.8f, -0.8f}, {0.8f, 0.8f, -0.8f} }
        };
        GLfloat vertices1[2][4][5] = {
            { {-0.8f, 0.8f, 0.8f,0.0f, 1.0f}, {-0.8f, -0.8f, 0.8f,0.0f, 0.0f},
              {0.8f, -0.8f, 0.8f,  1.0f, 0.0f}, {0.8f, 0.8f, 0.8f,  1.0f, 1.0f} },
            { {0.8f, 0.8f, 0.8f, 0.0f, 1.0f}, {0.8f, -0.8f, 0.8f, 0.0f, 0.0f},
              {0.8f, -0.8f, -0.8f, 1.0f, 0.0f}, {0.8f, 0.8f, -0.8f, 1.0f, 1.0f} }
        };
        vbo.create();
        vbo.bind();
        vbo.allocate(vertices1, 40*sizeof(GLfloat));
    
        GLuint attr = -1;
        attr = program->attributeLocation("vPosition");
    //    program->setAttributeBuffer(vPosition, GL_FLOAT, 0, 3, 0);
        program->setAttributeBuffer(attr, GL_FLOAT, 0, 3, sizeof(GLfloat) * 5);
        glEnableVertexAttribArray(attr);
    
        attr = program->attributeLocation("vTexCoord");
        program->setAttributeBuffer(attr, GL_FLOAT, 3*sizeof(GLfloat), 2, sizeof(GLfloat) * 5);
        glEnableVertexAttribArray(attr);
    
    //    GLuint vPosition = program->attributeLocation("vPosition");
    //    program->setAttributeBuffer(vPosition, GL_FLOAT, 0, 3, 0);
    //    glEnableVertexAttribArray(vPosition);
        // 纹理坐标
        GLfloat coords[2][4][2] = {
            { {0.0f, 1.0f}, {0.0f, 0.0f}, {1.0f, 0.0f}, {1.0f, 1.0f} },
            { {0.0f, 1.0f}, {0.0f, 0.0f}, {1.0f, 0.0f}, {1.0f, 1.0f} }
        };
    //    vbo.write(24*sizeof(GLfloat), coords, 16*sizeof(GLfloat));
    //    GLuint vTexCoord = program->attributeLocation("vTexCoord");
    //    program->setAttributeBuffer(vTexCoord, GL_FLOAT, 24*sizeof(GLfloat), 2, 0);
    //    glEnableVertexAttribArray(vTexCoord);
    
        program->setUniformValue("tex", 0);
    #endif
    
        QMatrix4x4 matrix;
        matrix.perspective(45.0f, (GLfloat)w/(GLfloat)h, 0.1f, 100.0f);
        matrix.translate(0, 0, translate);
        matrix.rotate(-60, 0, 1, 0);  //绕Y轴逆时针旋转
        matrix.rotate(xRot / 16.0f, 1.0f, 0.0f, 0.0f);
        matrix.rotate(yRot / 16.0f, 0.0f, 1.0f, 0.0f);
        matrix.rotate(zRot / 16.0f, 0.0f, 0.0f, 1.0f);
    
        program->setUniformValue("matrix", matrix);
    #ifdef PROGRAM_2D
    #else
        program->enableAttributeArray(PROGRAM_VERTEX_ATTRIBUTE);
        program->enableAttributeArray(PROGRAM_TEXCOORD_ATTRIBUTE);
        program->setAttributeBuffer(PROGRAM_VERTEX_ATTRIBUTE, GL_FLOAT, 0, 3, 5 * sizeof(GLfloat));
        program->setAttributeBuffer(PROGRAM_TEXCOORD_ATTRIBUTE, GL_FLOAT, 3 * sizeof(GLfloat), 2, 5 * sizeof(GLfloat));
    #endif
    
        // 绘制
    #ifdef PROGRAM_2D
        for(int i=0; i<2; i++)
    #else
        for(int i=0; i<6; i++)
    #endif
        {
            textures[i]->bind();
            glDrawArrays(GL_TRIANGLE_FAN, i*4, 4);
        }
    }
    
    
    void MyOpenGLWidget::mousePressEvent(QMouseEvent *event)
    {
        lastPos = event->pos();
    }
    
    void MyOpenGLWidget::mouseMoveEvent(QMouseEvent *event)
    {
        int dx = event->x() - lastPos.x();
        int dy = event->y() - lastPos.y();
    
        if (event->buttons() & Qt::LeftButton) {
            rotateBy(8 * dy, 8 * dx, 0);
        } else if (event->buttons() & Qt::RightButton) {
            rotateBy(8 * dy, 0, 8 * dx);
        }
        lastPos = event->pos();
    }
    
    void MyOpenGLWidget::mouseReleaseEvent(QMouseEvent *event)
    {
        emit clicked();
    }
    
    void MyOpenGLWidget::makeObject()
    {
        static const int coords[6][4][3] = {
            { { +1, -1, -1 }, { -1, -1, -1 }, { -1, +1, -1 }, { +1, +1, -1 } },
            { { +1, +1, -1 }, { -1, +1, -1 }, { -1, +1, +1 }, { +1, +1, +1 } },
            { { +1, -1, +1 }, { +1, -1, -1 }, { +1, +1, -1 }, { +1, +1, +1 } },
            { { -1, -1, -1 }, { -1, -1, +1 }, { -1, +1, +1 }, { -1, +1, -1 } },
            { { +1, -1, +1 }, { -1, -1, +1 }, { -1, -1, -1 }, { +1, -1, -1 } },
            { { -1, -1, +1 }, { +1, -1, +1 }, { +1, +1, +1 }, { -1, +1, +1 } }
        };
    
        for (int j = 0; j < 6; ++j)
            textures[j] = new QOpenGLTexture(QImage(QString(":/side%1.png").arg(j + 1)).mirrored());
    
        QVector<GLfloat> vertData;
        for (int i = 0; i < 6; ++i) {
            for (int j = 0; j < 4; ++j) {
                // vertex position
                vertData.append(0.5 * coords[i][j][0]);
                vertData.append(0.5 * coords[i][j][1]);
                vertData.append(0.5 * coords[i][j][2]);
                // texture coordinate
                vertData.append(j == 0 || j == 3);
                vertData.append(j == 0 || j == 1);
            }
        }
    
        vbo.create();
        vbo.bind();
        vbo.allocate(vertData.constData(), vertData.count() * sizeof(GLfloat));
    }
    
    void MyOpenGLWidget::printContextInformation()
    {
        QString glType;
        QString glVersion;
        QString glProfile;
    
        // Get Version Information
        glType = (context()->isOpenGLES()) ? "OpenGL ES" : "OpenGL";
        glVersion = reinterpret_cast<const char*>(glGetString(GL_VERSION));
    
        // Get Profile Information
      #define CASE(c) case QSurfaceFormat::c: glProfile = #c; break
        switch (format().profile())
        {
          CASE(NoProfile);
          CASE(CoreProfile);
          CASE(CompatibilityProfile);
        }
      #undef CASE
    
        // qPrintable() will print our QString w/o quotes around it.
        qDebug() << qPrintable(glType) << qPrintable(glVersion) << "(" << qPrintable(glProfile) << ")";
    }
    
    #include <QApplication>
    #include "myopenglwidget.h"
    
    int main(int argc, char *argv[])
    {
    
        Q_INIT_RESOURCE(textures);
        QApplication app(argc,argv);
    
        QSurfaceFormat format;
        format.setDepthBufferSize(24);
        QSurfaceFormat::setDefaultFormat(format);
    
        MyOpenGLWidget w;
        w.rotateBy(+42 * 16, +42 * 16, -21 * 16);
        w.setFormat(format);
        w.resize(400, 300);
        w.show();
        return app.exec();
    }

定义宏时的运行结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3A5NDIwMDU0MDU_size_16_color_FFFFFF_t_70][]

注释掉宏以后的运行效果：一个立方体

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3A5NDIwMDU0MDU_size_16_color_FFFFFF_t_70 1][]

[20191228001513880.png]: https://img-blog.csdnimg.cn/20191228001513880.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3A5NDIwMDU0MDU_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191228001639614.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3A5NDIwMDU0MDU=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3A5NDIwMDU0MDU_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20191228001742374.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3A5NDIwMDU0MDU=,size_16,color_FFFFFF,t_70