[关闭]
@cxm-2016 2017-04-05T14:28:22.000000Z 字数 12767 阅读 5473

NDK开发OpenGL ES 3.0(五)——一个立方体

OpenGL-ES

版本：2
作者：陈小默
声明：禁止商用，禁止转载

文章仅发布于 作业部落、简书、开源中国

上一篇：NDK开发OpenGL ES 3.0(四)——旋转的彩色方块

本章参考书：
[1]Dan Ginsburg,Budirjanto Purnomo.OpenGL ES 3.0 编程指南 第二版(姚军 译).北京：机械工业出版社

本篇主要介绍OpenGL ES中的图元装配和一些光栅化过程。学完本篇内容之后我们将会建造一个简单的旋转的立方体，就像下图所示。
最终效果图

九、图元装配和光栅化

本章主要内容是介绍基本图元，以及图元的装配和最终显示之前的光栅化。

9.1 基本图元

图元是由一组顶点描述的几何形状对象。在OpenGL中，任何图元都可以被绘制，但是在OpenGL ES中，由于其性能被精简(毕竟移动端CPU和GPU不比桌面设备)，所以只能绘制三种最基本的图元，但所有的图形都可以使用这三个基本图元来表示：

  • 点精灵
  • 直线
  • 三角形

9.1.1 点精灵

在OpenGL中，点精灵是指定位置和半径的屏幕对其的正方形，常用作粒子效果。

图元枚举：GL_POINTS
注意：默认情况下，点精灵的坐标原点是屏幕左上角。当我们决定绘制点的时候，需要在着色器中设置点的尺寸，否则，可能会造成绘图错误。在着色器中表示点精灵尺寸的变量是gl_PointSize。

9.1.2 直线

图元枚举：GL_LINES、GL_LINE_STRIP、GL_LINE_LOOP

说明：假设现在有[0，1，2，3，4]共5个点组成的数组，我们使用下列类型绘制的结果：

  • GL_LINES：绘制出[0，1]和[2，3]两条线，第五个点由于没有匹配点而被忽略。
  • GL_LINE_STRIP：绘制出[0，1]，[1，2]，[2，3]，[3，4]两两相连的四条线组成的折现。
  • GL_LINE_LOOP：绘制出[0，1]，[1，2]，[2，3]，[3，4]，[4，1]首尾相连的封闭图形。

其他函数：

void glLineWidth(GLfloat width);

  • width：指定线宽，默认为1.0

9.1.3 三角形

将一个图形分解为若干三角形是几何渲染最常用的方式

图元枚举：GL_TRIANGLES， GL_TRIANGLE_STRIP ，GL_TRIANGLE_FAN

说明：假设有[0，1，2，3，4，5，6]共7个点组成的数组，我们使用下列类型的绘制结果：

  • GL_TRIANGLES：绘制出[0，1，2]和[3，4，5]两个三角形，第7个点由于没有匹配点而被忽略。
  • GL_TRIANGLE_STRIP：绘制出[0，1，2]，[2，1，3]，[2，3，4]，[4，3，5]，[4，5，6]共5个三角形(绘制出偶数下标[n,n+1,n+2]和奇数下标[n+1,n,n+2]共n-2个三角形)
  • GL_TRIANGLE_FAN：绘制出[0，1，2]，[0，2，3]，[0，3，4]，[0，4，5]，[0，5，6]等共享顶点的5个三角形(绘制出[0,n+1,n+2]共n-2个三角形)

9.2 绘制图元

OpenGL ES提供了五种绘制图元的函数，分别是glDrawArrays、glDrawElements、glDrawRangeElement、glDrawArraysInstanced和glDrawElementsInstanced。接下来分别介绍这几种方法。

9.2.1 glDrawArrays

void glDrawArrays (GLenum mode, GLint first, GLsizei count);

  • mode：指定图元枚举，9.1节中的任意一个。
  • first：指定从顶点数组中的何处开始绘制。
  • count：需要绘制的顶点数量。

示例代码：

  1.     #define VERTEX_IND 0
  3.     GLfloat VERTICES[]={...};
  4.     glEnableVertexAttribArray(VERTEX_IND);
  5.     glVertexAttribPointer(VERTEX_IND,3,GL_FLOAT,GL_FALSE,0,VERTICES);
  7.     glDrawArrays(GL_TRIANGLES,0,3);

9.2.2 glDrawElements

该函数用来绘制图元，使用前需要创建图元索引列表。

void glDrawElements (GLenum mode, GLsizei count, GLenum type, const void *indices);

  • mode：指定图元枚举，9.1节中的任意一个。
  • count：指定要绘制的索引数量。
  • type：指定索引类型。
  • indices：索引数组。

示例代码：

  1.     #define VERTEX_IND 0
  2.     GLfloat VERTICES[]={
  3.             0.1f,0.3f,0.4f,//0
  4.             0.2f,0.5f,0.7f,//1
  5.             0.9f,-0.3f,0.8f,//2
  6.             0.4f,0.5f,-0.2f//3
  7.     };
  8.     GLubyte INDICES[]={
  9.             0,1,2,
  10.             3,2,1
  11.     };
  12.     glEnableVertexAttribArray(VERTEX_IND);
  13.     glVertexAttribPointer(VERTEX_IND,3,GL_FLOAT,GL_FALSE,0,VERTICES);
  15.     glDrawElements(GL_TRIANGLES,6,GL_UNSIGNED_BYTE,INDICES);

9.2.3 glDrawRangeElement

void glDrawRangeElements (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices);

  • mode：指定图元枚举，9.1节中的任意一个。
  • start：指定图元索引列表中最小值(从顶点数组何处开始)。
  • end：指定图元索引列表中的最大值(从顶点数组何处结束)。
  • count：指定要绘制的索引数量。
  • type：指定索引类型。
  • indices：索引数组。

示例代码(本例限定了仅顶点坐标中1-6有效，那么此次就只会绘制[3，4，5]这个三角形)：

  1.     #define VERTEX_IND 0
  2.     GLfloat VERTICES[] = {};//10个顶点
  3.     GLubyte INDICES[] = {
  4.             0, 1, 2,
  5.             0, 2, 3,
  6.             3, 4, 5,
  7.             7, 8, 9
  8.     };
  9.     glEnableVertexAttribArray(VERTEX_IND);
  10.     glVertexAttribPointer(VERTEX_IND, 3, GL_FLOAT, GL_FALSE, 0, VERTICES);
  12.     glDrawRangeElements(GL_TRIANGLES, 1, 6, 12, GL_UNSIGNED_BYTE, INDICES);
  13. }

9.3 图元装配光栅化过程

在图形经过顶点着色器处理之后，便进入了图元装配和光栅化的过程。其流程如下:

Created with Raphaël 2.1.2顶点着色器输出裁剪透视分割窗口变换剔除片元着色器输入

9.3.1 裁剪

在某些时候，我们的图元肯能超出了屏幕能够显示的范围。这时候，就需要对这些图元进行裁剪。

9.3.2 透视分割

透视分割取得裁剪坐标指定的点，并将其投影到屏幕或者是视图上。在过程中坐标将被转换为规范化坐标，即[-1.0..1.0]区间。

9.3.3 视口变换

视口是一个二维矩形窗口区域，是所有OpenGL ES渲染操作最终显示的地方。
void glViewport(GLint x,GLint y,GLsizei w,GLsizei h);
这个常用的方法指定了一个视口的区域。

9.4 剔除

在图形被光栅化之前，我们需要确定它是正面或者反面，这样可以剔除掉不需要显示的图形，仅保留可见部分。在剔除之前我们需要告诉OpenGL正反面的标准是什么。对于三角形图元，我们仅仅需要注明当前已逆时针为正还是逆时针。

void glFrontFace (GLenum mode);

  • mode：旋转方向GL_CW顺时针，GL_CCW逆时针

当我们指定了区分正反的方法之后，接下来可以调用下列方法剔除特定的面。

void glCullFace (GLenum mode);

  • mode：指定我们需要剔除的方向GL_FRONT剔除正面、GL_BACK剔除背面、GL_FRONT_AND_BACK剔除正面和背面

9.5 光栅化

在进行完以上操作之后，光栅化管线取得了单独的图元，并为该图元生成相应的片元(具体的像素点)。然后每个像素点都会经过片元着色器处理。

十、绘制一个旋转立方体

本章内容为绘制一个旋转的立方体的教程。本章只展示JNI部分的编写(暂不详解)，其他部分和之前相同，请自行实现。示例改编自OpenGL ES 3.0 编程指南 第七章示例代码目录结构如下：
10-1 目录部分

  1. #define LOG_TAG "cube-lib"
  3. #include "esUtil.h"
  4. #include <cmath>
  5. #include <ctime>
  7. #define PI 3.14
  9. #define POSITION_IND    0
  10. #define COLOR_IND       1
  11. #define MVP_IND         2
  12. #define VERTEX_NUM      108
  13. #define INDICES_NUM     36
  14. #define MATRIX_COLUMN   4
  15. #define MATRIX_ROW      4
  17. GLuint program;
  18. GLuint positionVBO;
  19. GLuint colorVBO;
  20. GLuint mvpVBO;
  21. GLuint indicesIBO;
  22. GLfloat aspect;
  23. uint64_t lastFrameNs;
  24. GLfloat angle;
  26. const char VERTEX_SHADER[] =
  27.         "#version 300 es\n"
  28.                 "layout(location = " STRV(POSITION_IND) ") in vec4 a_position;\n"
  29.                 "layout(location = " STRV(COLOR_IND) ") in vec4 a_color;\n"
  30.                 "layout(location = " STRV(MVP_IND) ") in mat4 a_mvpMatrix;\n"
  31.                 "out vec4 v_color;\n"
  32.                 "void main()\n"
  33.                 "{\n"
  34.                 "   v_color = a_color;\n"
  35.                 "   gl_Position = a_mvpMatrix * a_position;\n"
  36.                 "}\n";
  38. const char FRAGMENT_SHADER[] =
  39.         "#version 300 es\n"
  40.                 "precision mediump float;\n"
  41.                 "in vec4 v_color;\n"
  42.                 "layout(location = 0) out vec4 outColor;\n"
  43.                 "void main()\n"
  44.                 "{\n"
  45.                 "  outColor = v_color;\n"
  46.                 "}\n";
  48. GLfloat VERTEX_POS[VERTEX_NUM] =
  49.         {
  50.                 -0.5f, -0.5f, -0.5f,//0
  51.                 0.5f, -0.5f, 0.5f,//2
  52.                 -0.5f, -0.5f, 0.5f,//1
  53.                 -0.5f, -0.5f, -0.5f,//0
  54.                 0.5f, -0.5f, -0.5f,//3
  55.                 0.5f, -0.5f, 0.5f,//2
  56.                 -0.5f, 0.5f, -0.5f,//4
  57.                 -0.5f, 0.5f, 0.5f,//5
  58.                 0.5f, 0.5f, 0.5f,//6
  59.                 -0.5f, 0.5f, -0.5f,//4
  60.                 0.5f, 0.5f, 0.5f,//6
  61.                 0.5f, 0.5f, -0.5f,//7
  62.                 -0.5f, -0.5f, -0.5f,//0
  63.                 -0.5f, 0.5f, -0.5f,//4
  64.                 0.5f, 0.5f, -0.5f,//7
  65.                 -0.5f, -0.5f, -0.5f,//0
  66.                 0.5f, 0.5f, -0.5f,//7
  67.                 0.5f, -0.5f, -0.5f,//3
  68.                 -0.5f, -0.5f, 0.5f,//1
  69.                 0.5f, -0.5f, 0.5f,//2
  70.                 0.5f, 0.5f, 0.5f,//6
  71.                 -0.5f, -0.5f, 0.5f,//1
  72.                 0.5f, 0.5f, 0.5f,//6
  73.                 -0.5f, 0.5f, 0.5f,//5
  74.                 -0.5f, -0.5f, -0.5f,//0
  75.                 -0.5f, -0.5f, 0.5f,//1
  76.                 -0.5f, 0.5f, 0.5f,//5
  77.                 -0.5f, -0.5f, -0.5f,//0
  78.                 -0.5f, 0.5f, 0.5f,//5
  79.                 -0.5f, 0.5f, -0.5f,//4
  80.                 0.5f, -0.5f, -0.5f,//3
  81.                 0.5f, 0.5f, -0.5f,//7
  82.                 0.5f, 0.5f, 0.5f,//6
  83.                 0.5f, -0.5f, -0.5f,//3
  84.                 0.5f, 0.5f, 0.5f,//6
  85.                 0.5f, -0.5f, 0.5f//2
  86.         };
  88. const GLfloat cubeColor[] =
  89.         {
  90.                 1.0f, 0.0f, 0.0f, 0.0f,
  91.                 1.0f, 0.0f, 0.0f, 0.0f,
  92.                 1.0f, 0.0f, 0.0f, 0.0f,
  93.                 1.0f, 0.0f, 0.0f, 0.0f,
  94.                 1.0f, 0.0f, 0.0f, 0.0f,
  95.                 1.0f, 0.0f, 0.0f, 0.0f,
  97.                 0.0f, 0.0f, 1.0f, 0.0f,
  98.                 0.0f, 0.0f, 1.0f, 0.0f,
  99.                 0.0f, 0.0f, 1.0f, 0.0f,
  100.                 0.0f, 0.0f, 1.0f, 0.0f,
  101.                 0.0f, 0.0f, 1.0f, 0.0f,
  102.                 0.0f, 0.0f, 1.0f, 0.0f,
  104.                 0.0f, 1.0f, 0.0f, 0.0f,
  105.                 0.0f, 1.0f, 0.0f, 0.0f,
  106.                 0.0f, 1.0f, 0.0f, 0.0f,
  107.                 0.0f, 1.0f, 0.0f, 0.0f,
  108.                 0.0f, 1.0f, 0.0f, 0.0f,
  109.                 0.0f, 1.0f, 0.0f, 0.0f,
  111.                 1.0f, 1.0f, 0.0f, 0.0f,
  112.                 1.0f, 1.0f, 0.0f, 0.0f,
  113.                 1.0f, 1.0f, 0.0f, 0.0f,
  114.                 1.0f, 1.0f, 0.0f, 0.0f,
  115.                 1.0f, 1.0f, 0.0f, 0.0f,
  116.                 1.0f, 1.0f, 0.0f, 0.0f,
  118.                 0.0f, 1.0f, 1.0f, 0.0f,
  119.                 0.0f, 1.0f, 1.0f, 0.0f,
  120.                 0.0f, 1.0f, 1.0f, 0.0f,
  121.                 0.0f, 1.0f, 1.0f, 0.0f,
  122.                 0.0f, 1.0f, 1.0f, 0.0f,
  123.                 0.0f, 1.0f, 1.0f, 0.0f,
  125.                 1.0f, 0.0f, 1.0f, 0.0f,
  126.                 1.0f, 0.0f, 1.0f, 0.0f,
  127.                 1.0f, 0.0f, 1.0f, 0.0f,
  128.                 1.0f, 0.0f, 1.0f, 0.0f,
  129.                 1.0f, 0.0f, 1.0f, 0.0f,
  130.                 1.0f, 0.0f, 1.0f, 0.0f
  131.         };
  134. typedef struct {
  135.     GLfloat m[MATRIX_ROW][MATRIX_COLUMN];
  136. } Matrix;
  138. bool
  139. init() {
  140.     program = createProgram(VERTEX_SHADER, FRAGMENT_SHADER);
  141.     if (!program)
  142.         return false;
  144.     glGenBuffers(1, &positionVBO);
  145.     glBindBuffer(GL_ARRAY_BUFFER, positionVBO);
  146.     glBufferData(GL_ARRAY_BUFFER, VERTEX_NUM * sizeof(GLfloat), VERTEX_POS, GL_STATIC_DRAW);
  148.     glGenBuffers(1, &colorVBO);
  149.     glBindBuffer(GL_ARRAY_BUFFER, colorVBO);
  150.     glBufferData(GL_ARRAY_BUFFER, INDICES_NUM * 4 * sizeof(GLfloat), cubeColor, GL_STATIC_DRAW);
  152.     glBindBuffer(GL_ARRAY_BUFFER, colorVBO);
  153.     glVertexAttribPointer(COLOR_IND, 4, GL_FLOAT,
  154.                           GL_FALSE, 0, (const void *) NULL);
  155.     glEnableVertexAttribArray(COLOR_IND);
  157.     angle = float(drand48() * 360.0f);
  158.     glGenBuffers(1, &mvpVBO);
  159.     glBindBuffer(GL_ARRAY_BUFFER, mvpVBO);
  160.     glBufferData(GL_ARRAY_BUFFER, sizeof(Matrix), NULL, GL_DYNAMIC_DRAW);
  162.     glBindBuffer(GL_ARRAY_BUFFER, 0);
  163.     glClearColor(1.0f, 1.0f, 1.0f, 0.0f);
  165.     glBindBuffer(GL_ARRAY_BUFFER, positionVBO);
  166.     glVertexAttribPointer(POSITION_IND, 3, GL_FLOAT,
  167.                           GL_FALSE, 3 * sizeof(GLfloat), (const void *) NULL);
  168.     glEnableVertexAttribArray(POSITION_IND);
  170.     glBindBuffer(GL_ARRAY_BUFFER, mvpVBO);
  172.     glVertexAttribPointer(MVP_IND + 0, 4, GL_FLOAT, GL_FALSE, sizeof(Matrix),
  173.                           (const void *) NULL);
  174.     glVertexAttribPointer(MVP_IND + 1, 4, GL_FLOAT, GL_FALSE, sizeof(Matrix),
  175.                           (const void *) (sizeof(GLfloat) * 4));
  176.     glVertexAttribPointer(MVP_IND + 2, 4, GL_FLOAT, GL_FALSE, sizeof(Matrix),
  177.                           (const void *) (sizeof(GLfloat) * 8));
  178.     glVertexAttribPointer(MVP_IND + 3, 4, GL_FLOAT, GL_FALSE, sizeof(Matrix),
  179.                           (const void *) (sizeof(GLfloat) * 12));
  180.     glEnableVertexAttribArray(MVP_IND + 0);
  181.     glEnableVertexAttribArray(MVP_IND + 1);
  182.     glEnableVertexAttribArray(MVP_IND + 2);
  183.     glEnableVertexAttribArray(MVP_IND + 3);
  185.     glVertexAttribDivisor(MVP_IND + 0, 1);
  186.     glVertexAttribDivisor(MVP_IND + 1, 1);
  187.     glVertexAttribDivisor(MVP_IND + 2, 1);
  188.     glVertexAttribDivisor(MVP_IND + 3, 1);
  190.     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indicesIBO);
  192.     glUseProgram(program);
  194.     glFrontFace(GL_CCW);
  195.     glCullFace(GL_BACK);
  196.     glEnable(GL_CULL_FACE);
  198.     return true;
  199. }
  201. void
  202. matrixLoadIdentity(Matrix *result) {
  203.     memset(result, 0, sizeof(Matrix));
  204.     result->m[0][0] = 1.0f;
  205.     result->m[1][1] = 1.0f;
  206.     result->m[2][2] = 1.0f;
  207.     result->m[3][3] = 1.0f;
  208. }
  210. void
  211. matrixMultiply(Matrix *result, Matrix *srcA, Matrix *srcB) {
  212.     Matrix tmp;
  213.     int i;
  215.     for (i = 0; i < 4; i++) {
  216.         tmp.m[i][0] = (srcA->m[i][0] * srcB->m[0][0]) +
  217.                       (srcA->m[i][1] * srcB->m[1][0]) +
  218.                       (srcA->m[i][2] * srcB->m[2][0]) +
  219.                       (srcA->m[i][3] * srcB->m[3][0]);
  221.         tmp.m[i][1] = (srcA->m[i][0] * srcB->m[0][1]) +
  222.                       (srcA->m[i][1] * srcB->m[1][1]) +
  223.                       (srcA->m[i][2] * srcB->m[2][1]) +
  224.                       (srcA->m[i][3] * srcB->m[3][1]);
  226.         tmp.m[i][2] = (srcA->m[i][0] * srcB->m[0][2]) +
  227.                       (srcA->m[i][1] * srcB->m[1][2]) +
  228.                       (srcA->m[i][2] * srcB->m[2][2]) +
  229.                       (srcA->m[i][3] * srcB->m[3][2]);
  231.         tmp.m[i][3] = (srcA->m[i][0] * srcB->m[0][3]) +
  232.                       (srcA->m[i][1] * srcB->m[1][3]) +
  233.                       (srcA->m[i][2] * srcB->m[2][3]) +
  234.                       (srcA->m[i][3] * srcB->m[3][3]);
  235.     }
  237.     memcpy(result, &tmp, sizeof(Matrix));
  238. }
  240. void
  241. frustum(Matrix *result, float w, float h, float nearZ,
  242.         float farZ) {
  243.     float left = -w;
  244.     float right = w;
  245.     float bottom = -h;
  246.     float top = h;
  247.     float deltaX = right - left;
  248.     float deltaY = top - bottom;
  249.     float deltaZ = farZ - nearZ;
  250.     Matrix frust;
  252.     if ((nearZ <= 0.0f) || (farZ <= 0.0f) ||
  253.         (deltaX <= 0.0f) || (deltaY <= 0.0f) || (deltaZ <= 0.0f)) {
  254.         return;
  255.     }
  257.     frust.m[0][0] = 2.0f * nearZ / deltaX;
  258.     frust.m[0][1] = frust.m[0][2] = frust.m[0][3] = 0.0f;
  260.     frust.m[1][1] = 2.0f * nearZ / deltaY;
  261.     frust.m[1][0] = frust.m[1][2] = frust.m[1][3] = 0.0f;
  263.     frust.m[2][0] = (right + left) / deltaX;
  264.     frust.m[2][1] = (top + bottom) / deltaY;
  265.     frust.m[2][2] = -(nearZ + farZ) / deltaZ;
  266.     frust.m[2][3] = -1.0f;
  268.     frust.m[3][2] = -2.0f * nearZ * farZ / deltaZ;
  269.     frust.m[3][0] = frust.m[3][1] = frust.m[3][3] = 0.0f;
  271.     matrixMultiply(result, &frust, result);
  272. }
  274. void
  275. translate(Matrix *result, GLfloat tx, GLfloat ty, GLfloat tz) {
  276.     result->m[3][0] += (result->m[0][0] * tx + result->m[1][0] * ty + result->m[2][0] * tz);
  277.     result->m[3][1] += (result->m[0][1] * tx + result->m[1][1] * ty + result->m[2][1] * tz);
  278.     result->m[3][2] += (result->m[0][2] * tx + result->m[1][2] * ty + result->m[2][2] * tz);
  279.     result->m[3][3] += (result->m[0][3] * tx + result->m[1][3] * ty + result->m[2][3] * tz);
  280. }
  282. void
  283. rotate(Matrix *result, GLfloat angle, GLfloat x, GLfloat y, GLfloat z) {
  284.     GLfloat sinAngle, cosAngle;
  285.     GLfloat mag = sqrtf(x * x + y * y + z * z);
  287.     sinAngle = sinf(float(angle * PI / 180.0f));
  288.     cosAngle = cosf(float(angle * PI / 180.0f));
  290.     if (mag > 0.0f) {
  291.         GLfloat xx, yy, zz, xy, yz, zx, xs, ys, zs;
  292.         GLfloat oneMinusCos;
  293.         Matrix rotMat;
  295.         x /= mag;
  296.         y /= mag;
  297.         z /= mag;
  299.         xx = x * x;
  300.         yy = y * y;
  301.         zz = z * z;
  302.         xy = x * y;
  303.         yz = y * z;
  304.         zx = z * x;
  305.         xs = x * sinAngle;
  306.         ys = y * sinAngle;
  307.         zs = z * sinAngle;
  308.         oneMinusCos = 1.0f - cosAngle;
  310.         rotMat.m[0][0] = (oneMinusCos * xx) + cosAngle;
  311.         rotMat.m[0][1] = (oneMinusCos * xy) - zs;
  312.         rotMat.m[0][2] = (oneMinusCos * zx) + ys;
  313.         rotMat.m[0][3] = 0.0F;
  315.         rotMat.m[1][0] = (oneMinusCos * xy) + zs;
  316.         rotMat.m[1][1] = (oneMinusCos * yy) + cosAngle;
  317.         rotMat.m[1][2] = (oneMinusCos * yz) - xs;
  318.         rotMat.m[1][3] = 0.0F;
  320.         rotMat.m[2][0] = (oneMinusCos * zx) - ys;
  321.         rotMat.m[2][1] = (oneMinusCos * yz) + xs;
  322.         rotMat.m[2][2] = (oneMinusCos * zz) + cosAngle;
  323.         rotMat.m[2][3] = 0.0F;
  325.         rotMat.m[3][0] = 0.0F;
  326.         rotMat.m[3][1] = 0.0F;
  327.         rotMat.m[3][2] = 0.0F;
  328.         rotMat.m[3][3] = 1.0F;
  330.         matrixMultiply(result, &rotMat, result);
  331.     }
  332. }
  334. void
  335. update(float deltaTime) {
  336.     Matrix *matrixBuf;
  337.     Matrix perspective;
  339.     matrixLoadIdentity(&perspective);
  340.     GLfloat frustumW, frustumH;
  342.     frustumH = tanf(float(60.0f / 360.0f * PI)) * 1.5f;
  343.     frustumW = frustumH * aspect;
  345.     frustum(&perspective, frustumW, frustumH, 1.0f, 20.0f);
  347.     glBindBuffer(GL_ARRAY_BUFFER, mvpVBO);
  348.     matrixBuf = (Matrix *) glMapBufferRange(GL_ARRAY_BUFFER, 0, sizeof(Matrix),
  349.                                             GL_MAP_WRITE_BIT);
  351.     Matrix modelview;
  353.     matrixLoadIdentity(&modelview);
  355.     translate(&modelview, 0, 0, -2.0f);
  357.     angle += (deltaTime * 40.0f);
  358.     if (angle >= 360.0f) {
  359.         angle -= 360.0f;
  360.     }
  362.     rotate(&modelview, angle, 1.0, 0.0, 1.0);
  364.     matrixMultiply(&matrixBuf[0], &modelview, &perspective);
  366.     glUnmapBuffer(GL_ARRAY_BUFFER);
  367. }
  369. extern "C" {
  370. JNIEXPORT jboolean JNICALL Java_com_github_cccxm_gles_model_CubeLib_init(JNIEnv *env, jclass type);
  371. JNIEXPORT void JNICALL Java_com_github_cccxm_gles_model_CubeLib_resize(JNIEnv *env, jclass type,
  372.                                                                        jint width, jint height);
  373. JNIEXPORT void JNICALL Java_com_github_cccxm_gles_model_CubeLib_render(JNIEnv *env, jclass type);
  374. JNIEXPORT void JNICALL Java_com_github_cccxm_gles_model_CubeLib_destroy(JNIEnv *env, jclass type);
  375. }
  377. jboolean
  378. Java_com_github_cccxm_gles_model_CubeLib_init(JNIEnv *env, jclass type) {
  379.     if (init())return JNI_TRUE;
  380.     return JNI_FALSE;
  381. }
  384. void
  385. Java_com_github_cccxm_gles_model_CubeLib_resize(JNIEnv *env, jclass type,
  386.                                                 jint width, jint height) {
  387.     aspect = (GLfloat) width / (GLfloat) height;
  388.     glViewport(0, 0, width, height);
  389.     glClearColor(0, 0, 0, 0);
  390.     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  391. }
  393. void
  394. Java_com_github_cccxm_gles_model_CubeLib_render(JNIEnv *env, jclass type) {
  395.     timespec now;
  396.     clock_gettime(CLOCK_MONOTONIC, &now);
  397.     auto nowNs = now.tv_sec * 1000000000ull + now.tv_nsec;
  398.     if (lastFrameNs > 0) {
  399.         float dt = float(nowNs - lastFrameNs) * 0.000000001f;
  400.         update(dt);
  401.         glDrawArrays(GL_TRIANGLES, 0, 36);
  402.     }
  403.     lastFrameNs = nowNs;
  404. }
  406. void
  407. Java_com_github_cccxm_gles_model_CubeLib_destroy(JNIEnv *env, jclass type) {
  408.     glDeleteBuffers(1, &positionVBO);
  409.     glDeleteBuffers(1, &colorVBO);
  410.     glDeleteBuffers(1, &mvpVBO);
  411.     glDeleteBuffers(1, &indicesIBO);
  412.     glDeleteProgram(program);
  413. }
  415. #undef LOG_TAG

下一篇：NDK开发OpenGL ES 3.0(六)——2D纹理贴图

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注