Qt Opengl移植安卓出现的问题

Question

最近在学习opengl，目的是实现三维物体的绘制，使用的是，在PC端可以正常执行

Qt的安卓已经配置好了，但是在移植到安卓执行的时候突然编译出错

我使用的是QOpenGLFunctions_3_3_Core头文件，但是在编译的时候提示没有QOpenGLFunctions_3_3_Core这个类，导致项目一直编译不通过，请问各位这是什么原因呢？十分感谢

这是部分代码的截图

可以看到如果使用安卓Kits进行编译的话，QOpenGLFunctions_3_3_Core这个类是识别不出来的

Answer 1

• 这篇博客: QT中使用自带的OpenGL模块开发中的 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 <QOpenGLWidget>
  #include <QOpenGLFunctions>
  #include <QOpenGLShaderProgram>
  
  //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<QKeyEvent>
  #include<QGLWidget>
  #include<QOpenGLFunctions_3_2_Core>
  
  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 <QApplication>
  
  int main(int argc, char *argv[])
  {
      QApplication a(argc, argv);
  
      Widget widget(0);
      widget.show();
  
      return a.exec();
  }
  
  

  效果图：