[关闭]
@cxm-2016 2016-11-03T10:38:11.000000Z 字数 13033 阅读 2084

NDK开发OpenGL ES 3.0——工具类代码

OpenGL-ES

版本：1
作者：陈小默

ESUtil.h

  1. #ifndef GLES_ESUTIL_H
  2. #define GLES_ESUTIL_H
  4. #include <GLES3/gl3.h>
  5. #include <android/log.h>
  6. #include <jni.h>
  8. #ifndef LOG_TAG
  9. #define LOG_TAG "ES_LIB"
  10. #endif
  12. #define STR(s) #s
  13. #define STRV(s) STR(s)
  15. #define ALOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
  16. #define ALOGD(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__)
  18. #include <cstdlib>
  19. #include <cmath>
  21. #define  PI 3.1415
  24. //检查当前程序错误
  25. bool checkGlError(const char *funcName);
  27. //获取并编译着色器对象
  28. GLuint createShader(GLenum shaderType, const char *src);
  30. //使用着色器生成着色器程序对象
  31. GLuint createProgram(const char *vtxSrc, const char *fragSrc);
  34. //产生一个立方体
  35. int createCube(float scale, GLfloat **vertices, GLfloat **normals,
  36.                GLfloat **texCoords, GLuint **indices);
  38. int createSquareGrid ( int size, GLfloat **vertices, GLuint **indices );
  40. //生成一个球
  41. int createSphere(int numSlices, float radius, GLfloat **vertices, GLfloat **normals,
  42.                  GLfloat **texCoords, GLuint **indices);
  45. typedef struct {
  46.     GLfloat m[4][4];
  47. } Matrix;
  49. //初始化一个矩阵
  50. void matrixLoadIdentity(Matrix *result);
  52. //矩阵变换
  53. void translate(Matrix *result, GLfloat tx, GLfloat ty, GLfloat tz);
  55. //矩阵旋转
  56. void rotate(Matrix *result, GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
  58. //矩阵相乘
  59. void matrixMultiply(Matrix *result, Matrix *srcA, Matrix *srcB);
  61. //矩阵截取
  62. void frustum(Matrix *result, float w, float h, float nearZ, float farZ);
  64. //矩阵透视变换
  65. void perspective(Matrix *result, float fovy, float aspect, float nearZ, float farZ);
  67. void ortho(Matrix *result, float left, float right, float bottom, float top, float nearZ,
  68.            float farZ);
  70. void scale(Matrix *result, GLfloat sx, GLfloat sy, GLfloat sz);
  72. void matrixLookAt(Matrix *result, float posX, float posY, float posZ, float lookAtX, float lookAtY,
  73.                   float lookAtZ, float upX, float upY, float upZ);
  75. #endif

ESUtil.cpp

  1. #include "esUtil.h"
  3. bool checkGlError(const char *funcName) {
  4.     GLint err = glGetError();
  5.     if (err != GL_NO_ERROR) {
  6.         ALOGE("GL error after %s(): 0x%08x\n", funcName, err);
  7.         return true;
  8.     }
  9.     return false;
  10. }
  12. GLuint createShader(GLenum shaderType, const char *src) {
  13.     GLuint shader = glCreateShader(shaderType);
  14.     if (!shader) {
  15.         checkGlError("glCreateShader");
  16.         return 0;
  17.     }
  18.     glShaderSource(shader, 1, &src, NULL);
  20.     GLint compiled = GL_FALSE;
  21.     glCompileShader(shader);
  22.     glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
  23.     if (!compiled) {
  24.         GLint infoLogLen = 0;
  25.         glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLogLen);
  26.         if (infoLogLen > 0) {
  27.             GLchar *infoLog = (GLchar *) malloc(infoLogLen);
  28.             if (infoLog) {
  29.                 glGetShaderInfoLog(shader, infoLogLen, NULL, infoLog);
  30.                 ALOGE("Could not compile %s shader:\n%s\n",
  31.                       shaderType == GL_VERTEX_SHADER ? "vertex" : "fragment",
  32.                       infoLog);
  33.                 free(infoLog);
  34.             }
  35.         }
  36.         glDeleteShader(shader);
  37.         return 0;
  38.     }
  40.     return shader;
  41. }
  43. GLuint createProgram(const char *vtxSrc, const char *fragSrc) {
  44.     GLuint vtxShader = 0;
  45.     GLuint fragShader = 0;
  46.     GLuint program = 0;
  47.     GLint linked = GL_FALSE;
  49.     vtxShader = createShader(GL_VERTEX_SHADER, vtxSrc);
  50.     if (!vtxShader)
  51.         goto exit;
  53.     fragShader = createShader(GL_FRAGMENT_SHADER, fragSrc);
  54.     if (!fragShader)
  55.         goto exit;
  57.     program = glCreateProgram();
  58.     if (!program) {
  59.         checkGlError("glCreateProgram");
  60.         goto exit;
  61.     }
  62.     glAttachShader(program, vtxShader);
  63.     glAttachShader(program, fragShader);
  65.     glLinkProgram(program);
  66.     glGetProgramiv(program, GL_LINK_STATUS, &linked);
  67.     if (!linked) {
  68.         ALOGE("Could not link program");
  69.         GLint infoLogLen = 0;
  70.         glGetProgramiv(program, GL_INFO_LOG_LENGTH, &infoLogLen);
  71.         if (infoLogLen) {
  72.             GLchar *infoLog = (GLchar *) malloc(infoLogLen);
  73.             if (infoLog) {
  74.                 glGetProgramInfoLog(program, infoLogLen, NULL, infoLog);
  75.                 ALOGE("Could not link program:\n%s\n", infoLog);
  76.                 free(infoLog);
  77.             }
  78.         }
  79.         glDeleteProgram(program);
  80.         program = 0;
  81.     }
  83.     exit:
  84.     glDeleteShader(vtxShader);
  85.     glDeleteShader(fragShader);
  86.     return program;
  87. }
  89. void
  90. matrixMultiply(Matrix *result, Matrix *srcA, Matrix *srcB) {
  91.     Matrix tmp;
  92.     int i;
  94.     for (i = 0; i < 4; i++) {
  95.         tmp.m[i][0] = (srcA->m[i][0] * srcB->m[0][0]) +
  96.                       (srcA->m[i][1] * srcB->m[1][0]) +
  97.                       (srcA->m[i][2] * srcB->m[2][0]) +
  98.                       (srcA->m[i][3] * srcB->m[3][0]);
  100.         tmp.m[i][1] = (srcA->m[i][0] * srcB->m[0][1]) +
  101.                       (srcA->m[i][1] * srcB->m[1][1]) +
  102.                       (srcA->m[i][2] * srcB->m[2][1]) +
  103.                       (srcA->m[i][3] * srcB->m[3][1]);
  105.         tmp.m[i][2] = (srcA->m[i][0] * srcB->m[0][2]) +
  106.                       (srcA->m[i][1] * srcB->m[1][2]) +
  107.                       (srcA->m[i][2] * srcB->m[2][2]) +
  108.                       (srcA->m[i][3] * srcB->m[3][2]);
  110.         tmp.m[i][3] = (srcA->m[i][0] * srcB->m[0][3]) +
  111.                       (srcA->m[i][1] * srcB->m[1][3]) +
  112.                       (srcA->m[i][2] * srcB->m[2][3]) +
  113.                       (srcA->m[i][3] * srcB->m[3][3]);
  114.     }
  116.     memcpy(result, &tmp, sizeof(Matrix));
  117. }
  119. int createSquareGrid(int size, GLfloat **vertices, GLuint **indices) {
  120.     GLuint i, j;
  121.     int numIndices = (size - 1) * (size - 1) * 2 * 3;
  123.     // Allocate memory for buffers
  124.     if (vertices != NULL) {
  125.         int numVertices = size * size;
  126.         float stepSize = (float) size - 1;
  127.         *vertices = (GLfloat *) malloc(sizeof(GLfloat) * 3 * numVertices);
  129.         for (i = 0; i < size; ++i) // row
  130.         {
  131.             for (j = 0; j < size; ++j) // column
  132.             {
  133.                 (*vertices)[3 * (j + i * size)] = i / stepSize;
  134.                 (*vertices)[3 * (j + i * size) + 1] = j / stepSize;
  135.                 (*vertices)[3 * (j + i * size) + 2] = 0.0f;
  136.             }
  137.         }
  138.     }
  140.     // Generate the indices
  141.     if (indices != NULL) {
  142.         *indices = (GLuint *) malloc(sizeof(GLuint) * numIndices);
  144.         for (i = 0; i < size - 1; ++i) {
  145.             for (j = 0; j < size - 1; ++j) {
  146.                 // two triangles per quad
  147.                 (*indices)[6 * (j + i * (size - 1))] = j + (i) * (size);
  148.                 (*indices)[6 * (j + i * (size - 1)) + 1] = j + (i) * (size) + 1;
  149.                 (*indices)[6 * (j + i * (size - 1)) + 2] = j + (i + 1) * (size) + 1;
  151.                 (*indices)[6 * (j + i * (size - 1)) + 3] = j + (i) * (size);
  152.                 (*indices)[6 * (j + i * (size - 1)) + 4] = j + (i + 1) * (size) + 1;
  153.                 (*indices)[6 * (j + i * (size - 1)) + 5] = j + (i + 1) * (size);
  154.             }
  155.         }
  156.     }
  158.     return numIndices;
  159. }
  161. void
  162. frustum(Matrix *result, float w, float h, float nearZ,
  163.         float farZ) {
  164.     float left = -w;
  165.     float right = w;
  166.     float bottom = -h;
  167.     float top = h;
  168.     float deltaX = right - left;
  169.     float deltaY = top - bottom;
  170.     float deltaZ = farZ - nearZ;
  171.     Matrix frust;
  173.     if ((nearZ <= 0.0f) || (farZ <= 0.0f) ||
  174.         (deltaX <= 0.0f) || (deltaY <= 0.0f) || (deltaZ <= 0.0f)) {
  175.         return;
  176.     }
  178.     frust.m[0][0] = 2.0f * nearZ / deltaX;
  179.     frust.m[0][1] = frust.m[0][2] = frust.m[0][3] = 0.0f;
  181.     frust.m[1][1] = 2.0f * nearZ / deltaY;
  182.     frust.m[1][0] = frust.m[1][2] = frust.m[1][3] = 0.0f;
  184.     frust.m[2][0] = (right + left) / deltaX;
  185.     frust.m[2][1] = (top + bottom) / deltaY;
  186.     frust.m[2][2] = -(nearZ + farZ) / deltaZ;
  187.     frust.m[2][3] = -1.0f;
  189.     frust.m[3][2] = -2.0f * nearZ * farZ / deltaZ;
  190.     frust.m[3][0] = frust.m[3][1] = frust.m[3][3] = 0.0f;
  192.     matrixMultiply(result, &frust, result);
  193. }
  195. void
  196. rotate(Matrix *result, GLfloat angle, GLfloat x, GLfloat y, GLfloat z) {
  197.     GLfloat sinAngle, cosAngle;
  198.     GLfloat mag = sqrtf(x * x + y * y + z * z);
  200.     sinAngle = sinf(float(angle * PI / 180.0f));
  201.     cosAngle = cosf(float(angle * PI / 180.0f));
  203.     if (mag > 0.0f) {
  204.         GLfloat xx, yy, zz, xy, yz, zx, xs, ys, zs;
  205.         GLfloat oneMinusCos;
  206.         Matrix rotMat;
  208.         x /= mag;
  209.         y /= mag;
  210.         z /= mag;
  212.         xx = x * x;
  213.         yy = y * y;
  214.         zz = z * z;
  215.         xy = x * y;
  216.         yz = y * z;
  217.         zx = z * x;
  218.         xs = x * sinAngle;
  219.         ys = y * sinAngle;
  220.         zs = z * sinAngle;
  221.         oneMinusCos = 1.0f - cosAngle;
  223.         rotMat.m[0][0] = (oneMinusCos * xx) + cosAngle;
  224.         rotMat.m[0][1] = (oneMinusCos * xy) - zs;
  225.         rotMat.m[0][2] = (oneMinusCos * zx) + ys;
  226.         rotMat.m[0][3] = 0.0F;
  228.         rotMat.m[1][0] = (oneMinusCos * xy) + zs;
  229.         rotMat.m[1][1] = (oneMinusCos * yy) + cosAngle;
  230.         rotMat.m[1][2] = (oneMinusCos * yz) - xs;
  231.         rotMat.m[1][3] = 0.0F;
  233.         rotMat.m[2][0] = (oneMinusCos * zx) - ys;
  234.         rotMat.m[2][1] = (oneMinusCos * yz) + xs;
  235.         rotMat.m[2][2] = (oneMinusCos * zz) + cosAngle;
  236.         rotMat.m[2][3] = 0.0F;
  238.         rotMat.m[3][0] = 0.0F;
  239.         rotMat.m[3][1] = 0.0F;
  240.         rotMat.m[3][2] = 0.0F;
  241.         rotMat.m[3][3] = 1.0F;
  243.         matrixMultiply(result, &rotMat, result);
  244.     }
  245. }
  247. void
  248. translate(Matrix *result, GLfloat tx, GLfloat ty, GLfloat tz) {
  249.     result->m[3][0] += (result->m[0][0] * tx + result->m[1][0] * ty + result->m[2][0] * tz);
  250.     result->m[3][1] += (result->m[0][1] * tx + result->m[1][1] * ty + result->m[2][1] * tz);
  251.     result->m[3][2] += (result->m[0][2] * tx + result->m[1][2] * ty + result->m[2][2] * tz);
  252.     result->m[3][3] += (result->m[0][3] * tx + result->m[1][3] * ty + result->m[2][3] * tz);
  253. }
  255. void
  256. matrixLoadIdentity(Matrix *result) {
  257.     memset(result, 0, sizeof(Matrix));
  258.     result->m[0][0] = 1.0f;
  259.     result->m[1][1] = 1.0f;
  260.     result->m[2][2] = 1.0f;
  261.     result->m[3][3] = 1.0f;
  262. }
  264. int
  265. createCube(float scale, GLfloat **vertices, GLfloat **normals,
  266.            GLfloat **texCoords, GLuint **indices) {
  267.     int i;
  268.     int numVertices = 24;
  269.     int numIndices = 36;
  271.     GLfloat cubeVerts[] =
  272.             {
  273.                     -0.5f, -0.5f, -0.5f,
  274.                     -0.5f, -0.5f, 0.5f,
  275.                     0.5f, -0.5f, 0.5f,
  276.                     0.5f, -0.5f, -0.5f,
  277.                     -0.5f, 0.5f, -0.5f,
  278.                     -0.5f, 0.5f, 0.5f,
  279.                     0.5f, 0.5f, 0.5f,
  280.                     0.5f, 0.5f, -0.5f,
  281.                     -0.5f, -0.5f, -0.5f,
  282.                     -0.5f, 0.5f, -0.5f,
  283.                     0.5f, 0.5f, -0.5f,
  284.                     0.5f, -0.5f, -0.5f,
  285.                     -0.5f, -0.5f, 0.5f,
  286.                     -0.5f, 0.5f, 0.5f,
  287.                     0.5f, 0.5f, 0.5f,
  288.                     0.5f, -0.5f, 0.5f,
  289.                     -0.5f, -0.5f, -0.5f,
  290.                     -0.5f, -0.5f, 0.5f,
  291.                     -0.5f, 0.5f, 0.5f,
  292.                     -0.5f, 0.5f, -0.5f,
  293.                     0.5f, -0.5f, -0.5f,
  294.                     0.5f, -0.5f, 0.5f,
  295.                     0.5f, 0.5f, 0.5f,
  296.                     0.5f, 0.5f, -0.5f,
  297.             };
  299.     GLfloat cubeNormals[] =
  300.             {
  301.                     0.0f, -1.0f, 0.0f,
  302.                     0.0f, -1.0f, 0.0f,
  303.                     0.0f, -1.0f, 0.0f,
  304.                     0.0f, -1.0f, 0.0f,
  305.                     0.0f, 1.0f, 0.0f,
  306.                     0.0f, 1.0f, 0.0f,
  307.                     0.0f, 1.0f, 0.0f,
  308.                     0.0f, 1.0f, 0.0f,
  309.                     0.0f, 0.0f, -1.0f,
  310.                     0.0f, 0.0f, -1.0f,
  311.                     0.0f, 0.0f, -1.0f,
  312.                     0.0f, 0.0f, -1.0f,
  313.                     0.0f, 0.0f, 1.0f,
  314.                     0.0f, 0.0f, 1.0f,
  315.                     0.0f, 0.0f, 1.0f,
  316.                     0.0f, 0.0f, 1.0f,
  317.                     -1.0f, 0.0f, 0.0f,
  318.                     -1.0f, 0.0f, 0.0f,
  319.                     -1.0f, 0.0f, 0.0f,
  320.                     -1.0f, 0.0f, 0.0f,
  321.                     1.0f, 0.0f, 0.0f,
  322.                     1.0f, 0.0f, 0.0f,
  323.                     1.0f, 0.0f, 0.0f,
  324.                     1.0f, 0.0f, 0.0f,
  325.             };
  327.     GLfloat cubeTex[] =
  328.             {
  329.                     0.0f, 0.0f,
  330.                     0.0f, 1.0f,
  331.                     1.0f, 1.0f,
  332.                     1.0f, 0.0f,
  333.                     1.0f, 0.0f,
  334.                     1.0f, 1.0f,
  335.                     0.0f, 1.0f,
  336.                     0.0f, 0.0f,
  337.                     0.0f, 0.0f,
  338.                     0.0f, 1.0f,
  339.                     1.0f, 1.0f,
  340.                     1.0f, 0.0f,
  341.                     0.0f, 0.0f,
  342.                     0.0f, 1.0f,
  343.                     1.0f, 1.0f,
  344.                     1.0f, 0.0f,
  345.                     0.0f, 0.0f,
  346.                     0.0f, 1.0f,
  347.                     1.0f, 1.0f,
  348.                     1.0f, 0.0f,
  349.                     0.0f, 0.0f,
  350.                     0.0f, 1.0f,
  351.                     1.0f, 1.0f,
  352.                     1.0f, 0.0f,
  353.             };
  354.     if (vertices != NULL) {
  355.         *vertices = (GLfloat *) malloc(sizeof(GLfloat) * 3 * numVertices);
  356.         memcpy(*vertices, cubeVerts, sizeof(cubeVerts));
  358.         for (i = 0; i < numVertices * 3; i++) {
  359.             (*vertices)[i] *= scale;
  360.         }
  361.     }
  362.     if (normals != NULL) {
  363.         *normals = (GLfloat *) malloc(sizeof(GLfloat) * 3 * numVertices);
  364.         memcpy(*normals, cubeNormals, sizeof(cubeNormals));
  365.     }
  366.     if (texCoords != NULL) {
  367.         *texCoords = (GLfloat *) malloc(sizeof(GLfloat) * 2 * numVertices);
  368.         memcpy(*texCoords, cubeTex, sizeof(cubeTex));
  369.     }
  370.     if (indices != NULL) {
  371.         GLuint cubeIndices[] =
  372.                 {
  373.                         0, 2, 1,
  374.                         0, 3, 2,
  375.                         4, 5, 6,
  376.                         4, 6, 7,
  377.                         8, 9, 10,
  378.                         8, 10, 11,
  379.                         12, 15, 14,
  380.                         12, 14, 13,
  381.                         16, 17, 18,
  382.                         16, 18, 19,
  383.                         20, 23, 22,
  384.                         20, 22, 21
  385.                 };
  387.         *indices = (GLuint *) malloc(sizeof(GLuint) * numIndices);
  388.         memcpy(*indices, cubeIndices, sizeof(cubeIndices));
  389.     }
  390.     return numIndices;
  391. }
  393. void
  394. perspective(Matrix *result, float fovy, float aspect, float nearZ, float farZ) {
  395.     GLfloat frustumW, frustumH;
  397.     frustumH = tanf(float(fovy / 360.0f * PI)) * nearZ;
  398.     frustumW = frustumH * aspect;
  400.     frustum(result, frustumW, frustumH, nearZ, farZ);
  401. }
  403. void
  404. scale(Matrix *result, GLfloat sx, GLfloat sy, GLfloat sz) {
  405.     result->m[0][0] *= sx;
  406.     result->m[0][1] *= sx;
  407.     result->m[0][2] *= sx;
  408.     result->m[0][3] *= sx;
  410.     result->m[1][0] *= sy;
  411.     result->m[1][1] *= sy;
  412.     result->m[1][2] *= sy;
  413.     result->m[1][3] *= sy;
  415.     result->m[2][0] *= sz;
  416.     result->m[2][1] *= sz;
  417.     result->m[2][2] *= sz;
  418.     result->m[2][3] *= sz;
  419. }
  421. void
  422. matrixLookAt(Matrix *result,
  423.              float posX, float posY, float posZ,
  424.              float lookAtX, float lookAtY, float lookAtZ,
  425.              float upX, float upY, float upZ) {
  426.     float axisX[3], axisY[3], axisZ[3];
  427.     float length;
  429. // axisZ = lookAt - pos
  430.     axisZ[0] = lookAtX - posX;
  431.     axisZ[1] = lookAtY - posY;
  432.     axisZ[2] = lookAtZ - posZ;
  434. // normalize axisZ
  435.     length = sqrtf(axisZ[0] * axisZ[0] + axisZ[1] * axisZ[1] + axisZ[2] * axisZ[2]);
  437.     if (length != 0.0f) {
  438.         axisZ[0] /= length;
  439.         axisZ[1] /= length;
  440.         axisZ[2] /= length;
  441.     }
  443. // axisX = up X axisZ
  444.     axisX[0] = upY * axisZ[2] - upZ * axisZ[1];
  445.     axisX[1] = upZ * axisZ[0] - upX * axisZ[2];
  446.     axisX[2] = upX * axisZ[1] - upY * axisZ[0];
  448. // normalize axisX
  449.     length = sqrtf(axisX[0] * axisX[0] + axisX[1] * axisX[1] + axisX[2] * axisX[2]);
  451.     if (length != 0.0f) {
  452.         axisX[0] /= length;
  453.         axisX[1] /= length;
  454.         axisX[2] /= length;
  455.     }
  457. // axisY = axisZ x axisX
  458.     axisY[0] = axisZ[1] * axisX[2] - axisZ[2] * axisX[1];
  459.     axisY[1] = axisZ[2] * axisX[0] - axisZ[0] * axisX[2];
  460.     axisY[2] = axisZ[0] * axisX[1] - axisZ[1] * axisX[0];
  462. // normalize axisY
  463.     length = sqrtf(axisY[0] * axisY[0] + axisY[1] * axisY[1] + axisY[2] * axisY[2]);
  465.     if (length != 0.0f) {
  466.         axisY[0] /= length;
  467.         axisY[1] /= length;
  468.         axisY[2] /= length;
  469.     }
  471.     memset(result, 0x0, sizeof(Matrix));
  473.     result->m[0][0] = -axisX[0];
  474.     result->m[0][1] = axisY[0];
  475.     result->m[0][2] = -axisZ[0];
  477.     result->m[1][0] = -axisX[1];
  478.     result->m[1][1] = axisY[1];
  479.     result->m[1][2] = -axisZ[1];
  481.     result->m[2][0] = -axisX[2];
  482.     result->m[2][1] = axisY[2];
  483.     result->m[2][2] = -axisZ[2];
  485. // translate (-posX, -posY, -posZ)
  486.     result->m[3][0] = axisX[0] * posX + axisX[1] * posY + axisX[2] * posZ;
  487.     result->m[3][1] = -axisY[0] * posX - axisY[1] * posY - axisY[2] * posZ;
  488.     result->m[3][2] = axisZ[0] * posX + axisZ[1] * posY + axisZ[2] * posZ;
  489.     result->m[3][3] = 1.0f;
  490. }
  493. void
  494. ortho(Matrix *result, float left, float right, float bottom, float top, float nearZ,
  495.       float farZ) {
  496.     float deltaX = right - left;
  497.     float deltaY = top - bottom;
  498.     float deltaZ = farZ - nearZ;
  499.     Matrix ortho;
  501.     if ((deltaX == 0.0f) || (deltaY == 0.0f) || (deltaZ == 0.0f)) {
  502.         return;
  503.     }
  505.     matrixLoadIdentity(&ortho);
  506.     ortho.m[0][0] = 2.0f / deltaX;
  507.     ortho.m[3][0] = -(right + left) / deltaX;
  508.     ortho.m[1][1] = 2.0f / deltaY;
  509.     ortho.m[3][1] = -(top + bottom) / deltaY;
  510.     ortho.m[2][2] = -2.0f / deltaZ;
  511.     ortho.m[3][2] = -(nearZ + farZ) / deltaZ;
  513.     matrixMultiply(result, &ortho, result);
  514. }
  516. int
  517. createSphere(int numSlices, float radius, GLfloat **vertices, GLfloat **normals,
  518.              GLfloat **texCoords, GLuint **indices) {
  519.     int i;
  520.     int j;
  521.     int numParallels = numSlices / 2;
  522.     int numVertices = (numParallels + 1) * (numSlices + 1);
  523.     int numIndices = numParallels * numSlices * 6;
  524.     float angleStep = (float) (2.0f * PI) / numSlices;
  526.     // Allocate memory for buffers
  527.     if (vertices != NULL) {
  528.         *vertices = (GLfloat *) malloc(sizeof(GLfloat) * 3 * numVertices);
  529.     }
  531.     if (normals != NULL) {
  532.         *normals = (GLfloat *) malloc(sizeof(GLfloat) * 3 * numVertices);
  533.     }
  535.     if (texCoords != NULL) {
  536.         *texCoords = (GLfloat *) malloc(sizeof(GLfloat) * 2 * numVertices);
  537.     }
  539.     if (indices != NULL) {
  540.         *indices = (GLuint *) malloc(sizeof(GLuint) * numIndices);
  541.     }
  543.     for (i = 0; i < numParallels + 1; i++) {
  544.         for (j = 0; j < numSlices + 1; j++) {
  545.             int vertex = (i * (numSlices + 1) + j) * 3;
  547.             if (vertices) {
  548.                 (*vertices)[vertex + 0] = radius * sinf(angleStep * (float) i) *
  549.                                           sinf(angleStep * (float) j);
  550.                 (*vertices)[vertex + 1] = radius * cosf(angleStep * (float) i);
  551.                 (*vertices)[vertex + 2] = radius * sinf(angleStep * (float) i) *
  552.                                           cosf(angleStep * (float) j);
  553.             }
  555.             if (normals) {
  556.                 (*normals)[vertex + 0] = (*vertices)[vertex + 0] / radius;
  557.                 (*normals)[vertex + 1] = (*vertices)[vertex + 1] / radius;
  558.                 (*normals)[vertex + 2] = (*vertices)[vertex + 2] / radius;
  559.             }
  561.             if (texCoords) {
  562.                 int texIndex = (i * (numSlices + 1) + j) * 2;
  563.                 (*texCoords)[texIndex + 0] = (float) j / (float) numSlices;
  564.                 (*texCoords)[texIndex + 1] = (1.0f - (float) i) / (float) (numParallels - 1);
  565.             }
  566.         }
  567.     }
  568.     // Generate the indices
  569.     if (indices != NULL) {
  570.         GLuint *indexBuf = (*indices);
  572.         for (i = 0; i < numParallels; i++) {
  573.             for (j = 0; j < numSlices; j++) {
  574.                 *indexBuf++ = (GLuint) (i * (numSlices + 1) + j);
  575.                 *indexBuf++ = (GLuint) (i + 1) * (numSlices + 1) + j;
  576.                 *indexBuf++ = (GLuint) (i + 1) * (numSlices + 1) + (j + 1);
  578.                 *indexBuf++ = (GLuint) i * (numSlices + 1) + j;
  579.                 *indexBuf++ = (GLuint) (i + 1) * (numSlices + 1) + (j + 1);
  580.                 *indexBuf++ = (GLuint) i * (numSlices + 1) + (j + 1);
  581.             }
  582.         }
  583.     }
  584.     return numIndices;
  585. }
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注