QT中使用自带的OpenGL模块开发

NeHe的OpenGL教程
原文：http://nehe.gamedev.net/
翻译：https://www.cnblogs.com/arxive/p/6238969.html

QT中使用opengl用例，.pro文件中添加
QT += opengl

1、使用指定版本的OpenGL。.

如下使用opengl4.5调用方法，使用指定版本的接口，必须设备图形显示设备支持对应OpenGL版本才可。

Q：什么是CoreProfile和Compatibility Profile？
A：在OpenGL的发展历程中，总是兼顾向下兼容的特性，但是到了一定的程度之后，这些旧有的OpenGLAPI不再适应时代的需要，还有一些扩展并不是驱动一定要实现的扩展，这些被统一划入可选的CompatibilityProfile；而由OpenGL规范规定必须支持的扩展，则是Core Profile，想要支持先进的OpenGL，相应的CoreProfile扩展必须被实现。所以如果使用#include < QOpenGLFunctions > 或者 #include 时，会发现如glDrawPixels等接口找不到的问题。所以我们使用Cmpatibility版本。所有opengl的接口函数都可以使用。

#include 
//QOpenGLFunctions类提供了跨平台访问的OpenGL ES 2.0 API,QOpenGLFunctions提供了一个在所有OpenGL系统上都可用的保证API，并在需要它的系统上负责功能解析。使用QOpenGLFunctions的推荐方法是直接继承：
class Widget : public QOpenGLWidget, protected QOpenGLFunctions_4_5_Cmpatibility
{
public:
    Widget(QWidget *parent = 0);
    ~Widget();
    void initializeGL();                ///< 初始化
    void resizeGL(int w, int h);        ///< 当窗口发生变化时重新初始化
    void paintGL();                     ///< 绘制
}

void Widget::initializeGL()
{
    //获取上下文
    //QOpenGLFunctions_4_5_Compatibility* compatibility= QOpenGLContext::currentContext()->versionFunctions();
    //compatibility->initializeOpenGLFunctions();
    
    /* 0. 初始化函数，使得函数可以使用 */
    initializeOpenGLFunctions();

    const GLubyte* name = glGetString(GL_VENDOR); //返回负责当前OpenGL实现厂商的名字
    const GLubyte* biaoshifu = glGetString(GL_RENDERER); //返回一个渲染器标识符，通常是个硬件平台
    const GLubyte* OpenGLVersion =glGetString(GL_VERSION); //返回当前OpenGL实现的版本号
//    const GLubyte* OpenGLExensions =glGetString(GL_EXTENSIONS); //

    QString str;
    str.sprintf("%s | %s | %s",name,biaoshifu,OpenGLVersion);

    qDebug()<<str;
}

2、使用QOpenGLFunctions

QOpenGLFunctions类提供跨平台访问的OpenGL ES 2.0 API,QOpenGLFunctions提供了一个在所有OpenGL系统上都可用的保证API， 并在需要它的系统上负责功能解析。使用QOpenGLFunctions的推荐方法是直接继承，同时在初始化函数中void initializeGL() 调用此接口initializeOpenGLFunctions() 进行初始化。如下：

OpenGL ES相对OpenGL删减了一切低效能的操作方式，有高性能的决不留低效能的，即只求效能不求兼容性(和苹果的作风类似)。也就是说很多opengl函数无法使用，如glDrawPixels等。

典型：
1.没有double型数据类型，但加入了高性能的定点小数数据类型。
2.没有glBegin/glEnd/glVertex，只能用glDrawArrays/glDraw…
3.没有实时将非压缩图片数据转成压缩贴图的功能，程序必须直接提供压缩好的贴图

数据类型：
1: i GLint 整数型
2: f GLfixed 定点小数
3: x GLclampx 限定型定点小数

删除的功能：
1.glBegin/glEnd
2.glArrayElement
3.显示列表
4.求值器
5.索引色模式
6.自定义裁剪平面
7.glRect
8.图像处理(这个一般显卡也没有，FireGL/Quadro显卡有)
9.反馈缓冲
10.选择缓冲
11.累积缓冲
12.边界标志
13.glPolygonMode
14.GL_QUADS,GL_QUAD_STRIP,GL_POLYGON
15.glPushAttrib,glPopAttrib,glPushClientAttrib,glPopClientAttrib
15.TEXTURE_1D、TEXTURE_3D、TEXTURE_RECT、TEXTURE_CUBE_MAP
16.GL_COMBINE
17.自动纹理坐标生成
18.纹理边界
19.GL_CLAMP、GL_CLAMP_TO_BORDER
20.消失纹理代表
21.纹理LOD限定
22.纹理偏好限定
23.纹理自动压缩、解压缩
24.glDrawPixels,glPixelTransfer,glPixelZoom
25.glReadBuffer,glDrawBuffer,glCopyPixels

其它注意事项:
1.glDrawArrays等函数中数据必须紧密排列，即间隔为0
2.各种数据的堆栈深度较低

参考代码：

#ifndef WIDGET_H
#define WIDGET_H

#include 
#include 
#include 

//QOpenGLFunctions类提供了跨平台访问的OpenGL ES 2.0 API,QOpenGLFunctions提供了一个在所有OpenGL系统上都可用的保证API，并在需要它的系统上负责功能解析。使用QOpenGLFunctions的推荐方法是直接继承：
class Widget : public QOpenGLWidget, protected QOpenGLFunctions
{
public:
    Widget(QWidget *parent = 0);
    ~Widget();
    void initializeGL();                ///< 初始化
    void resizeGL(int w, int h);        ///< 当窗口发生变化时重新初始化
    void paintGL();                     ///< 绘制

    void initVbo();                     ///< 初始化Vbo
    void loadTextures();                ///< 加载纹理
    void keyPressEvent(QKeyEvent * e);  ///< 键盘事件
private:
    /* [1] 需要定点着色器和片段着色器，不然做不了任何渲染 */
    /*   这里定义了一个着色器[顶点着色器、片段着色器]编译对象 */
    QOpenGLShaderProgram * program;
    ///< 可以根据此id，利用glGetUniformLocation等方法获取shader里面的属性
    GLuint programid;

    ///< 其实还有视图矩阵、投影矩阵、MVP矩阵，这里简单的用下，不区分特别细！
    ///< 分三个这样的矩阵，分别是模型矩阵、视图矩阵、透视矩阵，这样以后灵活性更强:
    ///  1. 比如单独控制模型灯光跟随，shader可能需要传入除了mvp矩阵外的模型矩阵*视图矩阵这样一个矩阵
    QMatrix4x4 m_projection;

    ///< 矩阵、顶点、颜色在着色器里面的位置
    GLuint matrixLocation, vertexLocation, textureLocation,
           samplerLocation;

    ///< 顶点、索引、颜色->buffer的标识
    GLuint verVbo, v_indexVbo, textureVbo;
    GLuint texture;

    int vVerticesLen;   ///< 顶点数组长度
    int tri_indexLen;   ///< 索引数组长度
    int textureCoordLen;///< 纹理坐标数组长度
};

#endif // WIDGET_H

#include "widget.h"
#include
#include
#include

Widget::Widget(QWidget *parent) : QOpenGLWidget(parent)
{
    ///< 官方文档有这样设置，具体还没细细看，但是意思吧，就是告诉渲染属性，使用版本等；有空可以深入研究，光看效果不一定能看出什么区别!
    ///< 这个有些是放到main.cpp中去了，通过new widget.setFormat(format)那样去设置，不清楚...我觉得本质是一样，都是给该widget设置属性。
//    QSurfaceFormat format;
//    format.setDepthBufferSize(24);
//    format.setStencilBufferSize(8);
//    format.setVersion(3, 2);
//    format.setProfile(QSurfaceFormat::CoreProfile);
//    setFormat(format);
}

Widget::~Widget()
{
    glDeleteBuffers(1, &verVbo);
    glDeleteBuffers(1, &v_indexVbo);
    glDeleteProgram(programid);
    glDeleteTextures(1, &texture);
}

/* 1.1 着色器代码 */
/* *********************************************
 *   顶点着色器定义一个输入，它是 4 个成员的矢量 vPosition。
 *   主函数声明着色器宣布着色器开始执行。着色器主体非常简单，
 *   它复制输入 vPosition 属性到 gl_Position 输出变量中。
 *   每个顶点着色器必须输出位置值到 gl_Position 变量中，
 *   这个变量传入到管线的下一个阶段中。
 *   matrix主要是模型视图矩阵，控制位置和旋转等
 * ******************************************** */
/* 顶点着色器 */
static const char *vertexShaderSourceCore =
    "attribute vec4 vPosition;\n"
    "uniform highp mat4 matrix;\n"
    "attribute vec2 TexCoord;\n"
    "varying vec2 TexCoord0;\n"
    "void main() {\n"
    "   TexCoord0 = TexCoord;\n"
    "   gl_Position = matrix * vPosition;\n"
    "}\n";

/* *********************************************
 *   gl_FragColor，gl_FragColor是片段着色器最终的输出值，
 *   本例中输出值来自外部传入的颜色数组。
 * ******************************************** */

/* 片段着色器 */
static const char *fragmentShaderSourceCore =
    "varying vec2 TexCoord0;\n"
    "uniform sampler2D gSampler;\n"
    "void main() {\n"
    "   gl_FragColor = texture2D(gSampler, TexCoord0.st);\n"
    "}\n";


///* 2.1 三角形顶点的坐标 */
//GLfloat vVertices[] = {0.0f, 0.5f, 0.0f,
//                       -0.5f, -0.5f, 0.0f,
//                       0.5f, -0.5f, 0.0f};
///* 2.2 三角形顶点的索引 */
//GLuint tri_index[] = {0, 1, 2};
///* 2.3 顶点颜色数组 */
//GLfloat colors[] = {1.0f, 0.0f, 0.0f,0.5f,
//                    0.0f, 1.0f, 0.0f,0.5f,
//                    0.0f, 0.0f, 1.0f,0.5f};

/* 2.1 正方体顶点的坐标 */
GLfloat vVertices[] = {-0.5f, -0.5f, 0.5f,
                       0.5f, -0.5f, 0.5f,
                       -0.5f,  0.5f, 0.5f,
                       0.5f,  0.5f, 0.5f,

                       -0.5f, -0.5f,  -0.5f,
                       0.5f, -0.5f,  -0.5f,
                       -0.5f,  0.5f,  -0.5f,
                       0.5f,  0.5f,  -0.5f,

                       -0.5f, -0.5f,  -0.5f,
                       -0.5f, -0.5f,  0.5f,
                       -0.5f,  0.5f,  -0.5f,
                       -0.5f,  0.5f,  0.5f,

                       0.5f, -0.5f,  -0.5f,
                       0.5f, -0.5f,  0.5f,
                       0.5f,  0.5f,  -0.5f,
                       0.5f,  0.5f,  0.5f,

                       -0.5f, 0.5f,  -0.5f,
                       -0.5f, 0.5f,  0.5f,
                       0.5f,  0.5f,  -0.5f,
                       0.5f,  0.5f,  0.5f,

                       -0.5f, -0.5f,  -0.5f,
                       -0.5f, -0.5f,  0.5f,
                       0.5f,  -0.5f,  -0.5f,
                       0.5f,  -0.5f,  0.5f};
/* 2.2 正方体顶点的索引 */
GLuint tri_index[] = {0, 3, 2,
                      0, 1, 3,
                      4, 7, 6,
                      4, 5, 7,
                      8, 11, 10,
                      8, 9, 11,
                      12, 15, 14,
                      12, 13, 15,
                      16, 19, 18,
                      16, 17, 19,
                      20, 23, 22,
                      20, 21, 23};

///< 纹理点 6个面 每个面四个纹理坐标映射？？？好像不对呀，绘制出来花花的...
///< 还得好好思考下纹理坐标和现在的顶点索引坐标如何对应！！！
/// 下面这个先注释掉，上面的说法：六个面，每个面四个纹理坐标映射好像不对....
//float texCoords[] =
//{
//    0.0f, 0.0f,
//    1.0f, 0.0f,
//    0.0f, 1.0f,
//    1.0f, 1.0f,

//    0.0f, 0.0f,
//    1.0f, 0.0f,
//    0.0f, 1.0f,
//    1.0f, 1.0f,

//    0.0f, 0.0f,
//    1.0f, 0.0f,
//    0.0f, 1.0f,
//    1.0f, 1.0f,
//    0.0f, 0.0f,
//    1.0f, 0.0f,
//    0.0f, 1.0f,
//    1.0f, 1.0f,
//    0.0f, 0.0f,
//    1.0f, 0.0f,
//    0.0f, 1.0f,
//    1.0f, 1.0f,
//    0.0f, 0.0f,
//    1.0f, 0.0f,
//    0.0f, 1.0f,
//    1.0f, 1.0f
//};
///< 我们就来手动修改下，直到不花为止，然后回过头去细细分析下，具体原因？
///  这样学习起来更快，毕竟现有感觉，带着感觉去更加有激情和感悟...
///  不过按照自己认为的坐标去对应，始终不对(上下两面还是花)...哎，缓一缓，先仔细研究下再回过头来修改...
float texCoords[] =
{
    0.0f, 0.0f,
    1.0f, 0.0f,
    0.0f, 1.0f,
    1.0f, 1.0f,

    0.0f, 0.0f,
    1.0f, 0.0f,
    0.0f, 1.0f,
    1.0f, 1.0f,

    0.0f, 0.0f,
    1.0f, 0.0f,
    0.0f, 1.0f,
    1.0f, 1.0f,

    0.0f, 0.0f,
    1.0f, 0.0f,
    0.0f, 1.0f,
    1.0f, 1.0f,

    0.0f, 0.0f,
    1.0f, 0.0f,
    0.0f, 1.0f,
    1.0f, 1.0f,

    0.0f, 0.0f,
    1.0f, 0.0f,
    0.0f, 1.0f,
    1.0f, 1.0f
};

/**
 * @brief 初始化模型信息vbo【显存】
 */
void Widget::initVbo()
{
    ///< 计算获得数组长度，之后会用到该变量，这样只需要改动这里即可！如果用链表，直接.size()即可求出！
    vVerticesLen = sizeof(vVertices)/sizeof(GLfloat);
    tri_indexLen = sizeof(tri_index)/sizeof(GLuint);
    textureCoordLen = sizeof(texCoords)/sizeof(GLfloat);

    qDebug() << vVerticesLen;
    qDebug() << tri_indexLen;

    ///< 初始化顶点buffer并装载数据到显存
    glGenBuffers(1, &verVbo);
    glBindBuffer(GL_ARRAY_BUFFER, verVbo);
    glBufferData(GL_ARRAY_BUFFER, vVerticesLen * sizeof(GLfloat), vVertices, GL_STATIC_DRAW);

    ///< 初始化索引buffer并装载数据到显存
    glGenBuffers(1, &v_indexVbo);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, v_indexVbo);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, tri_indexLen * sizeof(GLuint), tri_index, GL_STATIC_DRAW);

    ///< 初始化纹理坐标buffer并装载到显存
    glGenBuffers(1, &textureVbo);
    glBindBuffer(GL_ARRAY_BUFFER, textureVbo);
    glBufferData(GL_ARRAY_BUFFER, textureCoordLen * sizeof(GLfloat), texCoords, GL_STATIC_DRAW);
}

/**
 * @brief 装载纹理，具体纹理知识可以参考网友资料：
 * http://www.cnblogs.com/tornadomeet/archive/2012/08/24/2654719.html
 */
void Widget::loadTextures()
{
    QImage tex, buf;
    if (!buf.load("../2012082420060914.jpg"))
    {
        qWarning("annot open the image...");
        QImage dummy(128, 128, QImage::Format_RGB32);
        dummy.fill(Qt::green);
        buf = dummy;
    }

    ///< 转换为OpenGL支持的格式
    tex = QGLWidget::convertToGLFormat(buf);

    ///< 开辟一个纹理内存，内存指向texture
    glGenTextures(1, &texture);
    ///< 将创建的纹理内存指向的内容绑定到纹理对象GL_TEXTURE_2D上，
    ///  经过这句代码后，以后对GL_TEXTURE_2D的操作的任何操作都同时对应与它所绑定的纹理对象
    glBindTexture(GL_TEXTURE_2D, texture);
    ///< 开始真正创建纹理数据
    glTexImage2D(GL_TEXTURE_2D, 0, 3, tex.width(), tex.height(),
                 0, GL_RGBA, GL_UNSIGNED_BYTE, tex.bits());

    ///< 当所显示的纹理比加载进来的纹理小时，采用GL_LINEAR的方法来处理
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
    ///< 当所显示的纹理比加载进来的纹理大时，采用GL_LINEAR的方法来处理
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
}

void Widget::initializeGL()
{
    qDebug("+++ initializeGL +++");
    /* 0. 初始化函数，使得函数可以使用 */
    initializeOpenGLFunctions();

    /* 创建项目对象链接着色器 */
    /* 1. 初始化最大的任务是装载顶点和片段着色器 */
    program = new QOpenGLShaderProgram(this);
    /* 一旦应用程序已经创建了顶点、片段着色器对象，
       * 它需要去创建项目对象，项目是最终的链接对象，
       * 每个着色器在被绘制前都应该联系到项目或者项目对象。
       * ***************************************** */
    /* 1.2 加载 */
    if(!program->addShaderFromSourceCode(QOpenGLShader::Vertex, vertexShaderSourceCore))
    {
        return;
    }
    if(!program->addShaderFromSourceCode(QOpenGLShader::Fragment, fragmentShaderSourceCore))
    {
        return;
    }

    /* 1.3 设置属性位置，将vPosition属性设置为位置0, vertex为位置1
           这里我就让程序自动分配，当然你也可以手动； 我在后面通过代码获取到了！
    */
    //program->bindAttributeLocation("vertex", 1);
    //program->bindAttributeLocation("vPosition", 0);
    //program->bindAttributeLocation("a_color", 1);
    //program->bindAttributeLocation("matrix", 2);

    /* 1.4 链接项目检查错误 */
    if( !program->link() )
    {
        return;
    }

    if( !program->bind() ){
        return ;
    }

    ///< 获取shaderprogram的id号，然后可以通过id号获取一些属性...
    programid = program->programId();

    ///< 从shaderprogram里面获取变量标识，总共用到两种方式，看你喜好！倾向第一种
    matrixLocation = glGetUniformLocation(programid, "matrix");
    vertexLocation = glGetAttribLocation(programid, "vPosition");
    textureLocation = program->attributeLocation("TexCoord");
    samplerLocation = program->uniformLocation("gSampler");

    ///< 初始化vbo，对于实时变化的数据，可能需要在paintGL()里面每次调用！
    initVbo();

    ///< 装载纹理
    loadTextures();

    ///< 允许采用2D纹理技术
    glEnable(GL_TEXTURE_2D);
    ///< 设置背景颜色
    glClearColor(0.5f, 0.5f, 0.5f, 0.0f);
    ///< 开启深度测试，避免颜色相互透过，具体需要自己深入学习的哦！
    glEnable(GL_DEPTH_TEST);
    ///< 设置深度测试类型 - 不设置也会默认
    glDepthFunc(GL_LEQUAL);

    ///< 这个地方先于resizeGL运行，所以这里设置无效！我一开始犯了这个错误!!!
    //m_projection.translate(0.0f, 0.0f, -1.0f);
}

void Widget::resizeGL(int w, int h)
{
    /* 2.1 viewport 设定窗口的原点 origin (x, y)、宽度和高度 */
    glViewport(0, 0, w, h);

    ///< 模型矩阵重置
    m_projection.setToIdentity();
    ///< 透视投影【做了简单容错】
    qreal aspect = qreal(w) / qreal(h ? h : 1);
    m_projection.perspective(60.0f, aspect, 1.0f, 100.0f);
    ///< 增加了模型矩阵，需要做一定偏移量，保证物体刚开始渲染出来时可以被看到！
    m_projection.translate(0.0f, 0.0f, -2.0f);
}

void Widget::paintGL()
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    ///< shader传入模型视图矩阵
    glUniformMatrix4fv(matrixLocation, 1, GL_FALSE, m_projection.data());

    ///< shader绑定并启用顶点数组buffer
    glBindBuffer(GL_ARRAY_BUFFER, verVbo);
    glEnableVertexAttribArray(vertexLocation);
    ///< 顶点xyz坐标，所以每三个作为一个顶点值
    glVertexAttribPointer( vertexLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);

    ///< shader绑定并顶点索引数组buffer - 索引无需启用
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, v_indexVbo);

    ///< 绑定纹理
    glUniform1i(samplerLocation, 0);
    glActiveTexture(GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, texture);
    glBindBuffer(GL_ARRAY_BUFFER, textureVbo);
    glEnableVertexAttribArray(textureLocation);
    ///< 2是标识两个float为一个纹理坐标，从varying vec2 TexCoord0也可以看出!
    glVertexAttribPointer(textureLocation, 2, GL_FLOAT, GL_FALSE, 0, 0);

    glDrawElements(GL_TRIANGLES, tri_indexLen, GL_UNSIGNED_INT, 0);

    ///< 解绑buffer、关闭启用顶点、颜色数组、解绑纹理
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindTexture(GL_TEXTURE_2D, 0);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glDisableVertexAttribArray(textureLocation);
    glDisableVertexAttribArray(vertexLocation);
}

/**
 * @brief 写了键盘监听事件，可以控制模型旋转，方便预览
 * @param k
 */
void Widget::keyPressEvent(QKeyEvent * k)
{
    qDebug("+++ keyPressEvent +++");
    if(k->key() == Qt::Key_A)
    {
        m_projection.rotate(4, 0, 1, 0);
    }
    else if(k->key() == Qt::Key_D)
    {
        m_projection.rotate(-4, 0, 1, 0);
    }
    else if(k->key() == Qt::Key_W)
    {
        m_projection.rotate(4, 1, 0, 0);
    }
    else if(k->key() == Qt::Key_S)
    {
        m_projection.rotate(-4, 1, 0, 0);
    }
    update();
}

#include "widget.h"
#include 

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);

    Widget widget(0);
    widget.show();

    return a.exec();
}

效果图：