【OpenGL ES】在Android上手撕一个mini版的渲染框架

1 前言

1.1 开发该框架的动机

​    OpenGL ES 是一个渲染指令接口集合，每渲染一帧图像都是一系列渲染指令的排列组合。常用的渲染指令约有 70 个，记住这些渲染指令及其排列组合方式，是一件痛苦的事情。另外，在图形开发中，经常因为功耗、丢帧等问题需要性能优化，如何从框架层面进行性能优化是一件有挑战的问题。
​    基于上述原因，笔者手撕了一个 nimi 版的渲染框架，将这些常用的渲染指令有条理地封装、组织、归类，方便愉快并高效地进行 OpenGL ES 渲染开发。笔者在 OpenGL ES 领域从业也有些时日，对现有碎片化的知识进行归纳凝练，形成系统的认知，是件势在必行的事。
1.2 为什么选择 native

​    之所以选择在 native 中开发该渲染框架，是为了使该框架具有更好的跨平台特性和渲染效率。目前大多数平台的 OpenGL ES API 基于 C++ 实现，因此只需更改少量代码就可以将该框架迁移到其他平台上；另外，C++ 代码相较于 Java 等代码具有更高的执行效率。Windows 上的实现详见 → 在Windows上手撕一个mini版的渲染框架。
1.3 一个 mini 版的渲染框架应该具备哪些能力

​    一个 mini 版的渲染框架需要对 OpenGL ES 的常用指令进行归类（如下图），封装 EGL、error check、Shader Program、Mesh、VAO、VBO、IBO、Texture、FBO 等类，方便开发者快速开发渲染程序，将更多的注意力聚焦在业务上，而不是如何去组织 OpenGL ES 指令上。

1.4 为什么强调 mini 版渲染框架

​    从渲染指令的角度来看，OpenGL ES 3.0 约有 300 个渲染指令，本文框架只封装其中最常用的 70 个，指令覆盖程度仍有较大提升空间。
​    从功能的角度来看，笔者深知一个成熟完备的渲染框架应该具备相机、光源、光照模型（Lambert、Phong、PBR 等）、阴影、射线拾取、重力、碰撞检测、粒子系统等功能。
​    鉴于上述原因，笔者审慎地保留了 "mini" 前缀。
1.5 本框架的优势

​    本框架具有以下优势。

• 封装友好：对常用的 EGL 和 GL 指令（约 70 个）进行封装，提供了 EGL 环境搭建、着色器程序生成、网格构建、纹理贴图、离屏渲染、异常检测等基础能力，方便开发者快速开发渲染程序，将精力从繁杂的渲染指令中解放出来，将更多的注意力聚焦到业务上。
  
• 代码规整：框架中多处设计了 bind 和 unbind 接口，用于绑定和解绑 OpenGL ES 状态机相关 “插槽”，如：VBO、IBO、VAO 中都设计了 bind 和 unbind 接口，ShaderProgram、Texture、FBO、TextureAction 中都设计了 bind 接口；另外，在 FBO 中设计了 begin 和 end 接口，很直观地告诉用户夹在这中间的内容将渲染到 FBO。接口规整简洁，方便用户记忆。
  
• 易于扩展：定义了 TextureAction 接口，并提供 bind 函数，GLTexture、FBO 都继承了 TextureAction，用户自定义的渲染器或特效类也可以继承 TextureAction，将它们统一视为纹理活动（可绑定），这在特效叠加（或后处理）中非常有用，方便管理多渲染目标图层，易于扩展。
  
• 性能高效：封装了 VBO、IBO、VAO，用于缓存顶点数据、索引、格式等信息到显存，减少 CPU 到 GPU 的数据传输，提高渲染效率；缓存了 attribute 和 uniform 变量的 location，避免 CPU 频繁向 GPU 查询 location，进一步提高渲染效率；基于 C++ 语言实现渲染框架，代码执行效率较高。
  
• 跨平台：基于 C++ 语言实现，具有更好的跨平台特性；封装了 core_lib，使得平台相关头文件可以轻松替换；封装了 Application，使得平台相关 api 可以轻松替换。
  
• 方便调试：设计了 EGL_CALL 和 GL_CALL 两个宏，对每个 EGL 和 GL 指令进行异常检测，方便调试渲染指令，并且通过预编译宏 DEBUG 开关动态控制是否生成异常检测的代码，Release 版本会自动屏蔽异常检测代码，避免带来额外功耗。
  

2 渲染框架

​    经过深思熟虑，笔者给该渲染框架命名为 glcore，命名空间也是 glcore。本文完整资源（包含 glcore 框架和第 4 节的应用）详见 → 【OpenGL ES】一个mini版的Android native渲染框架 。Windows 版本的 glcore 实现详见 → 在Windows上手撕一个mini版的渲染框架。
2.1 框架结构

2.2 CMakeLists

​    CMakeLists.txt

1. # 设置库名
2. set(LIB_NAME "glcore")
4. # 递归添加源文件列表
5. file(GLOB_RECURSE GL_CORE_SOURCES src *.cpp)
7. # 添加预构建库
8. add_library(${LIB_NAME} ${GL_CORE_SOURCES})
10. # 将当前目录设为公共头文件目录 (任何链接glcore库的目标都能自动获得这个头文件路径)
11. target_include_directories(${LIB_NAME} PUBLIC .)
13. # 添加链接的三方库文件
14. target_link_libraries(${LIB_NAME} PRIVATE
15.         android
16.         log
17.         EGL
18.         GLESv3)

复制代码

2.3 核心头文件

​    核心头文件分为对内和对外的，即内部依赖 core_lib，外部开放 core。
​    core_lib.h

1. #pragma once
3. /**
4. * glcore 依赖的核心 GL 库, 便于将 glcore 移植到其他平台
5. * Android: EGL + GLESv3
6. * Windows: glfw / freeglut + glad / glew
7. *
8. * @author little fat sheep
9. */
11. #include <EGL/egl.h>
12. #include <GLES3/gl3.h>

复制代码

​    之所以要单独拎出 core_lib.h，是为了方便将该框架迁移到其他平台，如 Windows 上依赖的三方渲染库是 glfw / freeglut + glad / glew，如果不抽出 core_lib.h，就需要将很多地方的 egl.h + gl3.h 改为 glfw3.h / freeglut.h + glad.h / glew.h，工作量大，也容易漏改。
​    core.h

1. #pragma once
3. /**
4. * glcore核心头文件
5. * 该头文件是留给外部使用的, glcore内部不能使用, 避免自己包含自己
6. * @author little fat sheep
7. */
9. // OpenGL ES API
10. #include "core_lib.h"
12. // glcore 核心头文件
13. #include "application.h"
14. #include "elg_surface_view.h"
15. #include "format.h"
16. #include "frame_buffer_object.h"
17. #include "gl_inspector.h"
18. #include "gl_texture.h"
19. #include "mesh.h"
20. #include "mesh_utils.h"
21. #include "shader_program.h"
22. #include "texture_action.h"
23. #include "vertex_attribute.h"

复制代码

​     core.h 只提供给外部使用，方便外部只需要包含一个头文件，就能获取 glcore 的基础能力。
2.4 Application

​    Application 主要用于管理全局环境，使用单例模式，方便获取一些全局的变量。它也是 glcore 中唯一一个依赖平台相关的接口（除日志 log 接口外），如：jniEnv、context、m_window 都是 Android 特有的，如果将 glcore 迁移到 Windows 中，这些变量全都要替换或删除，将这些平台相关变量都集中在 Application 中，迁移平台时修改起来也比较容易，避免太分散容易漏掉。
​    application.h

1. #pragma once
3. #include
4. #include <jni.h>
6. #define app Application::getInstance()
8. namespace glcore
9. {
10. /**
11. * 应用程序, 存储全局的参数, 便于访问
12. * @author little fat sheep
13. */
14. class Application {
15. private:
16.     static Application* sInstance;
18. public:
19.     JNIEnv* jniEnv = nullptr;
20.     jobject context = nullptr;
21.     int width = 0;
22.     int height = 0;
23.     float aspect = 1.0f;
25. private:
26.     ANativeWindow* m_window = nullptr;
28. public:
29.     static Application* getInstance();
30.     ~Application();
31.     void resize(int width, int height);
32.     ANativeWindow* getWindow() { return m_window; }
33.     void setWindow(ANativeWindow* window);
34.     void releaseWindow();
36. private:
37.     Application() {};
38. };
39. } // namespace glcore

复制代码

​    application.cpp

1. #include "glcore/application.h"
3. namespace glcore
4. {
5. Application* Application::sInstance = nullptr;
7. Application *Application::getInstance()
8. {
9.     if (sInstance == nullptr)
10.     {
11.         sInstance = new Application();
12.     }
13.     return sInstance;
14. }
16. Application::~Application()
17. {
18.     jniEnv->DeleteGlobalRef(context);
19.     releaseWindow();
20. }
22. void Application::resize(int width, int height)
23. {
24.     this->width = width;
25.     this->height = height;
26.     this->aspect = (float) width / (float) height;
27. }
29. void Application::setWindow(ANativeWindow* window)
30. {
31.     m_window = window;
32.     resize(ANativeWindow_getWidth(window), ANativeWindow_getHeight(window));
33. }
35. void Application::releaseWindow()
36. {
37.     if (m_window)
38.     {
39.         ANativeWindow_release(m_window);
40.         m_window = nullptr;
41.     }
42. }
43. } // namespace glcore

复制代码

2.5 GLInspector

​    GLInspector 主要用于异常信息检测，另外设计了 EGL_CALL 和 GL_CALL 两个宏，分别对 EGL 和 GL 指令进行装饰。如果定义了 DEBUG 宏，就会对每个 EGL 和 GL 指令进行异常检测，方便调试代码；如果未定义了 DEBUG 宏，就不会进行异常检测。
​    用户可以在 CMakeLists.txt 中添加预编译宏 DEBUG，这样就可以根据 Release 和 Debug 版本自动构建不同的版本。

1. if (CMAKE_BUILD_TYPE STREQUAL "Debug")
2.     # 添加预编译宏
3.     add_definitions(-DDEBUG)
4. endif ()

复制代码

​    gl_inspector.h

1. #pragma once
3. #include "core_lib.h"
5. #ifdef DEBUG
6. #define EGL_CALL(func) func;GLInspector::checkEGLError();
7. #define GL_CALL(func) func;GLInspector::checkGLError();
8. #else
9. #define EGL_CALL(func) func;
10. #define GL_CALL(func) func;
11. #endif
13. namespace glcore
14. {
15. /**
16. * OpenGL ES命令报错监视器
17. * @author little fat sheep
18. */
19. class GLInspector
20. {
21. public:
22.     static void checkEGLError(const char* tag); // 检查EGL报错信息
23.     static void checkEGLError(); // 通用检查EGL错误
24.     static void printShaderInfoLog(GLuint shader, const char* tag); // 打印Shader错误日志
25.     static void printProgramInfoLog(GLuint program, const char* tag); // 打印Program错误日志
26.     static void checkGLError(const char* tag); // 检查GL报错信息
27.     static void checkGLError(); // 通用检查GL报错信息
28. };
29. } // namespace glcore

复制代码

​    gl_inspector.cpp

1. #include
2. #include
3. #include <string>
5. #include "glcore/gl_inspector.h"
7. #define LOG_TAG "Native: GLInspector"
8. #define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
10. using namespace std;
12. namespace glcore
13. {
14. void GLInspector::checkEGLError(const char *tag)
15. {
16.     int error = eglGetError();
17.     if (error != EGL_SUCCESS) {
18.         LOGE("%s failed: 0x%x", tag, error);
19.     }
20. }
22. void GLInspector::checkEGLError()
23. {
24.     GLenum errorCode = eglGetError();
25.     if (errorCode != EGL_SUCCESS) {
26.         string error;
27.         switch (errorCode)
28.         {
29.             case EGL_BAD_DISPLAY:
30.                 error = "EGL_BAD_DISPLAY";
31.                 break;
32.             case EGL_NOT_INITIALIZED:
33.                 error = "EGL_NOT_INITIALIZED";
34.                 break;
35.             case EGL_BAD_CONFIG:
36.                 error = "EGL_BAD_CONFIG";
37.                 break;
38.             case EGL_BAD_CONTEXT:
39.                 error = "EGL_BAD_CONTEXT";
40.                 break;
41.             case EGL_BAD_NATIVE_WINDOW:
42.                 error = "EGL_BAD_NATIVE_WINDOW";
43.                 break;
44.             case EGL_BAD_SURFACE:
45.                 error = "EGL_BAD_SURFACE";
46.                 break;
47.             case EGL_BAD_CURRENT_SURFACE:
48.                 error = "EGL_BAD_CURRENT_SURFACE";
49.                 break;
50.             case EGL_BAD_ACCESS:
51.                 error = "EGL_BAD_ACCESS";
52.                 break;
53.             case EGL_BAD_ALLOC:
54.                 error = "EGL_BAD_ALLOC";
55.                 break;
56.             case EGL_BAD_ATTRIBUTE:
57.                 error = "EGL_BAD_ATTRIBUTE";
58.                 break;
59.             case EGL_BAD_PARAMETER:
60.                 error = "EGL_BAD_PARAMETER";
61.                 break;
62.             case EGL_BAD_NATIVE_PIXMAP:
63.                 error = "EGL_BAD_NATIVE_PIXMAP";
64.                 break;
65.             case EGL_BAD_MATCH:
66.                 error = "EGL_BAD_MATCH";
67.                 break;
68.             case EGL_CONTEXT_LOST:
69.                 error = "EGL_CONTEXT_LOST";
70.                 break;
71.             default:
72.                 error = "UNKNOW";
73.                 break;
74.         }
75.         LOGE("checkEGLError failed: %s, 0x%x", error.c_str(), errorCode);
76.         assert(false);
77.     }
78. }
80. void GLInspector::printShaderInfoLog(GLuint shader, const char* tag)
81. {
82.     char infoLog[512];
83.     glGetShaderInfoLog(shader, 512, nullptr, infoLog);
84.     LOGE("%s failed: %s", tag, infoLog);
85. }
87. void GLInspector::printProgramInfoLog(GLuint program, const char* tag)
88. {
89.     char infoLog[512];
90.     glGetProgramInfoLog(program, 512, nullptr, infoLog);
91.     LOGE("%s failed: %s", tag, infoLog);
92. }
94. void GLInspector::checkGLError(const char *tag) {
95.     GLenum error = glGetError();
96.     if(error != GL_NO_ERROR) {
97.         LOGE("%s failed: 0x%x", tag, error);
98.     }
99. }
101. void GLInspector::checkGLError()
102. {
103.     GLenum errorCode = glGetError();
104.     if (errorCode != GL_NO_ERROR) {
105.         string error;
106.         switch (errorCode)
107.         {
108.             case GL_INVALID_ENUM:
109.                 error = "GL_INVALID_ENUM";
110.                 break;
111.             case GL_INVALID_VALUE:
112.                 error = "GL_INVALID_VALUE";
113.                 break;
114.             case GL_INVALID_OPERATION:
115.                 error = "GL_INVALID_OPERATION";
116.                 break;
117.             case GL_INVALID_INDEX:
118.                 error = "GL_INVALID_INDEX";
119.                 break;
120.             case GL_INVALID_FRAMEBUFFER_OPERATION:
121.                 error = "GL_INVALID_FRAMEBUFFER_OPERATION";
122.                 break;
123.             case GL_OUT_OF_MEMORY:
124.                 error = "GL_OUT_OF_MEMORY";
125.                 break;
126.             default:
127.                 error = "UNKNOW";
128.                 break;
129.         }
130.         LOGE("checkGLError failed: %s, 0x%x", error.c_str(), errorCode);
131.         assert(false);
132.     }
133. }
134. } // namespace glcore

复制代码

2.6 EGLSurfaceView

​    EGLSurfaceView 主要承载了 EGL 环境搭建。EGL 详细介绍见 → 【OpenGL ES】EGL+FBO离屏渲染。
​    elg_surface_view.h

1. #include
3. #include "glcore/application.h"
4. #include "glcore/elg_surface_view.h"
5. #include "glcore/gl_inspector.h"
7. #define LOG_TAG "Native: EGLSurfaceView"
8. #define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
10. namespace glcore
11. {
12. EGLSurfaceView::EGLSurfaceView()
13. {
14.     LOGI("init");
15.     createDisplay();
16.     createConfig();
17.     createContext();
18. }
20. EGLSurfaceView::~EGLSurfaceView()
21. {
22.     LOGI("destroy");
23.     if (m_renderer)
24.     {
25.         delete m_renderer;
26.         m_renderer = nullptr;
27.     }
28.     if (m_eglDisplay && m_eglDisplay != EGL_NO_DISPLAY)
29.     {
30.         // 与显示设备解绑
31.         EGL_CALL(eglMakeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
32.         // 销毁 EGLSurface
33.         if (m_eglSurface && m_eglSurface != EGL_NO_SURFACE)
34.         {
35.             EGL_CALL(eglDestroySurface(m_eglDisplay, m_eglSurface));
36.             delete &m_eglSurface;
37.         }
38.         // 销毁 EGLContext
39.         if (m_eglContext && m_eglContext != EGL_NO_CONTEXT)
40.         {
41.             EGL_CALL(eglDestroyContext(m_eglDisplay, m_eglContext));
42.             delete &m_eglContext;
43.         }
44.         // 销毁 EGLDisplay (显示设备)
45.         EGL_CALL(eglTerminate(m_eglDisplay));
46.         delete &m_eglDisplay;
47.     }
48.     delete app;
49. }
51. void EGLSurfaceView::setRenderer(Renderer *renderer)
52. {
53.     LOGI("setRenderer");
54.     m_renderer = renderer;
55. }
57. bool EGLSurfaceView::surfaceCreated()
58. {
59.     LOGI("createSurface");
60.     createSurface();
61.     makeCurrent();
62.     if (m_renderer && m_firstCreateSurface)
63.     {
64.         m_renderer->onSurfaceCreated();
65.         m_firstCreateSurface = false;
66.     }
67.     return true;
68. }
70. void EGLSurfaceView::surfaceChanged(int width, int height)
71. {
72.     LOGI("surfaceChanged, width: %d, height: %d", width, height);
73.     app->resize(width, height);
74.     if (m_renderer)
75.     {
76.         m_renderer->onSurfaceChanged(width, height);
77.     }
78. }
80. void EGLSurfaceView::drawFrame()
81. {
82.     if (!m_eglSurface || m_eglSurface == EGL_NO_SURFACE || !m_renderer)
83.     {
84.         return;
85.     }
86.     m_renderer->onDrawFrame();
87.     EGL_CALL(eglSwapBuffers(m_eglDisplay, m_eglSurface));
88. }
90. void EGLSurfaceView::surfaceDestroy()
91. {
92.     LOGI("surfaceDestroy");
93.     if (m_eglDisplay && m_eglDisplay != EGL_NO_DISPLAY)
94.     {
95.         // 与显示设备解绑
96.         EGL_CALL(eglMakeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
97.         // 销毁 EGLSurface
98.         if (m_eglSurface && m_eglSurface != EGL_NO_SURFACE)
99.         {
100.             EGL_CALL(eglDestroySurface(m_eglDisplay, m_eglSurface));
101.             m_eglSurface = nullptr;
102.         }
103.     }
104.     app->releaseWindow();
105. }
107. // 1.创建EGLDisplay
108. void EGLSurfaceView::createDisplay()
109. {
110.     EGL_CALL(m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY));
111.     EGL_CALL(eglInitialize(m_eglDisplay, nullptr, nullptr));
112. }
114. // 2.创建EGLConfig
115. void EGLSurfaceView::createConfig()
116. {
117.     if (m_eglDisplay && m_eglDisplay != EGL_NO_DISPLAY)
118.     {
119.         const EGLint configAttrs[] = {
120.                 EGL_RED_SIZE, 8,
121.                 EGL_GREEN_SIZE, 8,
122.                 EGL_BLUE_SIZE, 8,
123.                 EGL_ALPHA_SIZE, 8,
124.                 EGL_DEPTH_SIZE, 8,
125.                 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES3_BIT,
126.                 EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
127.                 EGL_NONE
128.         };
129.         EGLint numConfigs;
130.         EGL_CALL(eglChooseConfig(m_eglDisplay, configAttrs, &m_eglConfig, 1, &numConfigs));
131.     }
132. }
134. // 3.创建EGLContext
135. void EGLSurfaceView::createContext()
136. {
137.     if (m_eglConfig)
138.     {
139.         const EGLint contextAttrs[] = {
140.                 EGL_CONTEXT_CLIENT_VERSION, 3,
141.                 EGL_NONE
142.         };
143.         EGL_CALL(m_eglContext = eglCreateContext(m_eglDisplay, m_eglConfig, EGL_NO_CONTEXT, contextAttrs));
144.     }
145. }
147. // 4.创建EGLSurface
148. void EGLSurfaceView::createSurface()
149. {
150.     if (m_eglContext && m_eglContext != EGL_NO_CONTEXT)
151.     {
152.         EGL_CALL(m_eglSurface = eglCreateWindowSurface(m_eglDisplay, m_eglConfig, app->getWindow(), nullptr));
153.     }
154. }
156. // 5.绑定EGLSurface和EGLContext到显示设备（EGLDisplay）
157. void EGLSurfaceView::makeCurrent()
158. {
159.     if (m_eglSurface && m_eglSurface != EGL_NO_SURFACE)
160.     {
161.         EGL_CALL(eglMakeCurrent(m_eglDisplay, m_eglSurface, m_eglSurface, m_eglContext));
162.     }
163. }
164. } // namespace glcore

复制代码

​    elg_surface_view.cpp

1. #include
3. #include "glcore/application.h"
4. #include "glcore/elg_surface_view.h"
5. #include "glcore/gl_inspector.h"
7. #define LOG_TAG "Native: EGLSurfaceView"
8. #define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
10. namespace glcore
11. {
12. EGLSurfaceView::EGLSurfaceView()
13. {
14.     LOGI("init");
15.     createDisplay();
16.     createConfig();
17.     createContext();
18. }
20. EGLSurfaceView::~EGLSurfaceView()
21. {
22.     LOGI("destroy");
23.     if (m_renderer)
24.     {
25.         delete m_renderer;
26.         m_renderer = nullptr;
27.     }
28.     if (m_eglDisplay && m_eglDisplay != EGL_NO_DISPLAY)
29.     {
30.         // 与显示设备解绑
31.         EGL_CALL(eglMakeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
32.         // 销毁 EGLSurface
33.         if (m_eglSurface && m_eglSurface != EGL_NO_SURFACE)
34.         {
35.             EGL_CALL(eglDestroySurface(m_eglDisplay, m_eglSurface));
36.             //GLInspector::checkEGLConfig("eglDestroySurface");
37.             delete &m_eglSurface;
38.         }
39.         // 销毁 EGLContext
40.         if (m_eglContext && m_eglContext != EGL_NO_CONTEXT)
41.         {
42.             EGL_CALL(eglDestroyContext(m_eglDisplay, m_eglContext));
43.             //GLInspector::checkEGLConfig("eglDestroyContext");
44.             delete &m_eglContext;
45.         }
46.         // 销毁 EGLDisplay (显示设备)
47.         EGL_CALL(eglTerminate(m_eglDisplay));
48.         //GLInspector::checkEGLConfig("eglTerminate");
49.         delete &m_eglDisplay;
50.     }
51.     delete app;
52. }
54. void EGLSurfaceView::setRenderer(Renderer *renderer)
55. {
56.     LOGI("setRenderer");
57.     m_renderer = renderer;
58. }
60. bool EGLSurfaceView::surfaceCreated()
61. {
62.     LOGI("createSurface");
63.     createSurface();
64.     makeCurrent();
65.     if (m_renderer && m_firstCreateSurface)
66.     {
67.         m_renderer->onSurfaceCreated();
68.         m_firstCreateSurface = false;
69.     }
70.     return true;
71. }
73. void EGLSurfaceView::surfaceChanged(int width, int height)
74. {
75.     LOGI("surfaceChanged, width: %d, height: %d", width, height);
76.     app->resize(width, height);
77.     if (m_renderer)
78.     {
79.         m_renderer->onSurfaceChanged(width, height);
80.     }
81. }
83. void EGLSurfaceView::drawFrame()
84. {
85.     if (!m_eglSurface || m_eglSurface == EGL_NO_SURFACE || !m_renderer)
86.     {
87.         return;
88.     }
89.     m_renderer->onDrawFrame();
90.     EGL_CALL(eglSwapBuffers(m_eglDisplay, m_eglSurface));
91.     //GLInspector::checkEGLConfig("eglSwapBuffers");
92. }
94. void EGLSurfaceView::surfaceDestroy()
95. {
96.     LOGI("surfaceDestroy");
97.     if (m_eglDisplay && m_eglDisplay != EGL_NO_DISPLAY)
98.     {
99.         // 与显示设备解绑
100.         EGL_CALL(eglMakeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
101.         // 销毁 EGLSurface
102.         if (m_eglSurface && m_eglSurface != EGL_NO_SURFACE)
103.         {
104.             EGL_CALL(eglDestroySurface(m_eglDisplay, m_eglSurface));
105.             //GLInspector::checkEGLConfig("eglDestroySurface");
106.             m_eglSurface = nullptr;
107.         }
108.     }
109.     app->releaseWindow();
110. }
112. // 1.创建EGLDisplay
113. void EGLSurfaceView::createDisplay()
114. {
115.     EGL_CALL(m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY));
116.     EGL_CALL(eglInitialize(m_eglDisplay, nullptr, nullptr));
117.     //GLInspector::checkEGLConfig("eglInitialize");
118. }
120. // 2.创建EGLConfig
121. void EGLSurfaceView::createConfig()
122. {
123.     if (m_eglDisplay && m_eglDisplay != EGL_NO_DISPLAY)
124.     {
125.         const EGLint configAttrs[] = {
126.                 EGL_RED_SIZE, 8,
127.                 EGL_GREEN_SIZE, 8,
128.                 EGL_BLUE_SIZE, 8,
129.                 EGL_ALPHA_SIZE, 8,
130.                 EGL_DEPTH_SIZE, 8,
131.                 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES3_BIT,
132.                 EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
133.                 EGL_NONE
134.         };
135.         EGLint numConfigs;
136.         EGL_CALL(eglChooseConfig(m_eglDisplay, configAttrs, &m_eglConfig, 1, &numConfigs));
137.         //GLInspector::checkEGLConfig("eglChooseConfig");
138.     }
139. }
141. // 3.创建EGLContext
142. void EGLSurfaceView::createContext()
143. {
144.     if (m_eglConfig)
145.     {
146.         const EGLint contextAttrs[] = {
147.                 EGL_CONTEXT_CLIENT_VERSION, 3,
148.                 EGL_NONE
149.         };
150.         EGL_CALL(m_eglContext = eglCreateContext(m_eglDisplay, m_eglConfig, EGL_NO_CONTEXT, contextAttrs));
151.         //GLInspector::checkEGLConfig("eglCreateContext");
152.     }
153. }
155. // 4.创建EGLSurface
156. void EGLSurfaceView::createSurface()
157. {
158.     if (m_eglContext && m_eglContext != EGL_NO_CONTEXT)
159.     {
160.         EGL_CALL(m_eglSurface = eglCreateWindowSurface(m_eglDisplay, m_eglConfig, app->getWindow(), nullptr));
161.         //GLInspector::checkEGLConfig("eglCreateWindowSurface");
162.     }
163. }
165. // 5.绑定EGLSurface和EGLContext到显示设备（EGLDisplay）
166. void EGLSurfaceView::makeCurrent()
167. {
168.     if (m_eglSurface && m_eglSurface != EGL_NO_SURFACE)
169.     {
170.         EGL_CALL(eglMakeCurrent(m_eglDisplay, m_eglSurface, m_eglSurface, m_eglContext));
171.         //GLInspector::checkEGLConfig("eglMakeCurrent");
172.     }
173. }
174. } // namespace glcore

复制代码

2.7 ShaderProgram

​    ShaderProgram 主要用于编译 Shader、链接 Program、设置 attribute 属性、更新 uniform 属性。
​    glGetAttribLocation、glGetUniformLocation 两个接口需要 CPU 向 GPU 查询 location 信息，并且会频繁调用，为提高性能，笔者设计了 m_attributes 和 m_uniforms 两个 map 存储 name 到 location 的映射，方便快速获取 location，避免 CPU 频繁与 GPU 交互，以提高渲染性能。
​    shader_program.h

1. #pragma once
3. #include <map>
5. #include "core_lib.h"
7. using namespace std;
9. namespace glcore
10. {
11. /**
12. * 着色器程序
13. * @author little fat sheep
14. */
15. class ShaderProgram
16. {
17. public:
18.     static constexpr char* ATTRIBUTE_POSITION = "a_position"; // 着色器中位置属性名
19.     static constexpr char* ATTRIBUTE_NORMAL = "a_normal"; // 着色器中位法线性名
20.     static constexpr char* ATTRIBUTE_COLOR = "a_color"; // 着色器中颜色属性名
21.     static constexpr char* ATTRIBUTE_TEXCOORD = "a_texCoord"; // 着色器中纹理坐标属性名
22.     static constexpr char* ATTRIBUTE_TANGENT = "a_tangent"; // 着色器中切线属性名
23.     static constexpr char* ATTRIBUTE_BINORMAL = "a_binormal"; // 着色器中副切线属性名
25.     static constexpr char* UNIFORM_TEXTURE = "u_texture"; // 着色器中纹理名
26.     static constexpr char* UNIFORM_VP = "u_projectionViewMatrix"; // 着色器中VP名
28. private:
29.     GLuint m_program;
30.     map<const char*, int> m_attributes;
31.     map<const char*, int> m_uniforms;
33. public:
34.     ShaderProgram(const char* vertexCode, const char* fragmentCode);
35.     ~ShaderProgram();
36.     void bind();
37.     GLuint getHandle() { return m_program; }
39.     // 操作attribute属性
40.     void enableVertexAttribArray(const char* name);
41.     void enableVertexAttribArray(int location);
42.     void setVertexAttribPointer(const char* name, int size, int type, bool normalize, int stride, int offset);
43.     void setVertexAttribPointer(int location, int size, int type, bool normalize, int stride, int offset);
44.     void disableVertexAttribArray(const char* name);
45.     void disableVertexAttribArray(int location);
47.     // 操作uniform属性
48.     void setUniformi(const char* name, int value);
49.     void setUniformi(int location, int value);
50.     void setUniformi(const char* name, int value1, int value2);
51.     void setUniformi(int location, int value1, int value2);
52.     void setUniformi(const char* name, int value1, int value2, int value3);
53.     void setUniformi(int location, int value1, int value2, int value3);
54.     void setUniformi(const char* name, int value1, int value2, int value3, int value4);
55.     void setUniformi(int location, int value1, int value2, int value3, int value4);
56.     void setUniformf(const char* name, float value);
57.     void setUniformf(int location, float value);
58.     void setUniformf(const char* name, float value1, float value2);
59.     void setUniformf(int location, float value1, float value2);
60.     void setUniformf(const char* name, float value1, float value2, int value3);
61.     void setUniformf(int location, float value1, float value2, int value3);
62.     void setUniformf(const char* name, float value1, float value2, int value3, int value4);
63.     void setUniformf(int location, float value1, float value2, int value3, int value4);
64.     void setUniform1fv(const char* name, int length, const float values[]);
65.     void setUniform1fv(int location, int count, float const values[]);
66.     void setUniform2fv(const char* name, int count, const float values[]);
67.     void setUniform2fv(int location, int count, const float values[]);
68.     void setUniform3fv(const char* name, int count, const float values[]);
69.     void setUniform3fv(int location, int count, const float values[]);
70.     void setUniform4fv(const char* name, int count, const float values[]);
71.     void setUniform4fv(int location, int count, const float values[]);
72.     void setUniformMatrix2fv(const char* name, int count, bool transpose, const float *value);
73.     void setUniformMatrix2fv(int location, int count, bool transpose, const float *value);
74.     void setUniformMatrix3fv(const char* name, int count, bool transpose, const float *value);
75.     void setUniformMatrix3fv(int location, int count, bool transpose, const float *value);
76.     void setUniformMatrix4fv(const char* name, int count, bool transpose, const float *value);
77.     void setUniformMatrix4fv(int location, int count, bool transpose, const float *value);
79.     int fetchAttributeLocation(const char* name);
80.     int fetchUniformLocation(const char* name);
82. private:
83.     void compileShaders(const char* vertexCode, const char* fragmentCode);
84.     GLuint loadShader(GLenum type, const char* source);
85.     GLuint linkProgram(GLuint vertexShader, GLuint fragmentShader);
86. };
87. } // namespace glcore

复制代码

​    shader_program.cpp

1. #include
3. #include "glcore/gl_inspector.h"
4. #include "glcore/shader_program.h"
6. #define LOG_TAG "Native: ShaderProgram"
7. #define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
9. namespace glcore
10. {
11. ShaderProgram::ShaderProgram(const char* vertexCode, const char* fragmentCode)
12. {
13.     compileShaders(vertexCode, fragmentCode);
14. }
16. ShaderProgram::~ShaderProgram()
17. {
18.     if (m_program)
19.     {
20.         GL_CALL(glUseProgram(0));
21.         GL_CALL(glDeleteProgram(m_program));
22.         m_program = 0;
23.     }
24.     m_attributes.clear();
25.     m_uniforms.clear();
26. }
28. void ShaderProgram::bind()
29. {
30.     GL_CALL(glUseProgram(m_program));
31. }
33. void ShaderProgram::enableVertexAttribArray(const char* name)
34. {
35.     int location = fetchAttributeLocation(name);
36.     enableVertexAttribArray(location);
37. }
39. void ShaderProgram::enableVertexAttribArray(int location)
40. {
41.     GL_CALL(glEnableVertexAttribArray(location));
42. }
44. void ShaderProgram::setVertexAttribPointer(const char *name, int size, int type, bool normalize, int stride, int offset)
45. {
46.     int location = fetchAttributeLocation(name);
47.     setVertexAttribPointer(location, size, type, normalize, stride, offset);
48. }
50. void ShaderProgram::setVertexAttribPointer(int location, int size, int type, bool normalize, int stride, int offset)
51. {
52.     GL_CALL(glVertexAttribPointer(location, size, type, normalize, stride, (void*) offset));
53. }
55. void ShaderProgram::disableVertexAttribArray(const char* name)
56. {
57.     int location = fetchAttributeLocation(name);
58.     disableVertexAttribArray(location);
59. }
61. void ShaderProgram::disableVertexAttribArray(int location)
62. {
63.     GL_CALL(glDisableVertexAttribArray(location));
64. }
66. void ShaderProgram::setUniformi(const char* name, int value)
67. {
68.     int location = fetchUniformLocation(name);
69.     GL_CALL(glUniform1i(location, value));
70. }
72. void ShaderProgram::setUniformi(int location, int value)
73. {
74.     GL_CALL(glUniform1i(location, value));
75. }
77. void ShaderProgram::setUniformi(const char* name, int value1, int value2)
78. {
79.     int location = fetchUniformLocation(name);
80.     GL_CALL(glUniform2i(location, value1, value2));
81. }
83. void ShaderProgram::setUniformi(int location, int value1, int value2)
84. {
85.     GL_CALL(glUniform2i(location, value1, value2));
86. }
88. void ShaderProgram::setUniformi(const char* name, int value1, int value2, int value3)
89. {
90.     int location = fetchUniformLocation(name);
91.     GL_CALL(glUniform3i(location, value1, value2, value3));
92. }
94. void ShaderProgram::setUniformi(int location, int value1, int value2, int value3)
95. {
96.     GL_CALL(glUniform3i(location, value1, value2, value3));
97. }
99. void ShaderProgram::setUniformi(const char* name, int value1, int value2, int value3, int value4)
100. {
101.     int location = fetchUniformLocation(name);
102.     GL_CALL(glUniform4i(location, value1, value2, value3, value4));
103. }
105. void ShaderProgram::setUniformi(int location, int value1, int value2, int value3, int value4)
106. {
107.     GL_CALL(glUniform4i(location, value1, value2, value3, value4));
108. }
110. void ShaderProgram::setUniformf(const char* name, float value)
111. {
112.     int location = fetchUniformLocation(name);
113.     GL_CALL(glUniform1f(location, value));
114. }
116. void ShaderProgram::setUniformf(int location, float value)
117. {
118.     GL_CALL(glUniform1f(location, value));
119. }
121. void ShaderProgram::setUniformf(const char* name, float value1, float value2)
122. {
123.     int location = fetchUniformLocation(name);
124.     GL_CALL(glUniform2f(location, value1, value2));
125. }
127. void ShaderProgram::setUniformf(int location, float value1, float value2)
128. {
129.     GL_CALL(glUniform2f(location, value1, value2));
130. }
132. void ShaderProgram::setUniformf(const char* name, float value1, float value2, int value3)
133. {
134.     int location = fetchUniformLocation(name);
135.     GL_CALL(glUniform3f(location, value1, value2, value3));
136. }
138. void ShaderProgram::setUniformf(int location, float value1, float value2, int value3)
139. {
140.     GL_CALL(glUniform3f(location, value1, value2, value3));
141. }
143. void ShaderProgram::setUniformf(const char* name, float value1, float value2, int value3, int value4)
144. {
145.     int location = fetchUniformLocation(name);
146.     GL_CALL(glUniform4f(location, value1, value2, value3, value4));
147. }
149. void ShaderProgram::setUniformf(int location, float value1, float value2, int value3, int value4)
150. {
151.     GL_CALL(glUniform4f(location, value1, value2, value3, value4));
152. }
154. void ShaderProgram::setUniform1fv(const char* name, int count, const float values[])
155. {
156.     int location = fetchUniformLocation(name);
157.     GL_CALL(glUniform1fv(location, count, values));
158. }
160. void ShaderProgram::setUniform1fv(int location, int count, const float values[])
161. {
162.     GL_CALL(glUniform1fv(location, count, values));
163. }
165. void ShaderProgram::setUniform2fv(const char* name, int count, const float values[])
166. {
167.     int location = fetchUniformLocation(name);
168.     GL_CALL(glUniform2fv(location, count / 2, values));
169. }
171. void ShaderProgram::setUniform2fv(int location, int count, const float values[])
172. {
173.     GL_CALL(glUniform2fv(location, count / 2, values));
174. }
176. void ShaderProgram::setUniform3fv(const char* name, int count, const float values[])
177. {
178.     int location = fetchUniformLocation(name);
179.     GL_CALL(glUniform3fv(location, count / 3, values));
180. }
182. void ShaderProgram::setUniform3fv(int location, int count, const float values[])
183. {
184.     GL_CALL(glUniform3fv(location, count / 3, values));
185. }
187. void ShaderProgram::setUniform4fv(const char* name, int count, const float values[])
188. {
189.     int location = fetchUniformLocation(name);
190.     GL_CALL(glUniform4fv(location, count / 4, values));
191. }
193. void ShaderProgram::setUniform4fv(int location, int count, const float values[])
194. {
195.     GL_CALL(glUniform4fv(location, count / 4, values));
196. }
198. void ShaderProgram::setUniformMatrix2fv(const char* name, int count, bool transpose, const float *value)
199. {
200.     int location = fetchUniformLocation(name);
201.     GL_CALL(glUniformMatrix2fv(location, count, transpose, value));
202. }
204. void ShaderProgram::setUniformMatrix2fv(int location, int count, bool transpose, const float *value)
205. {
206.     GL_CALL(glUniformMatrix2fv(location, count, transpose, value));
207. }
209. void ShaderProgram::setUniformMatrix3fv(const char* name, int count, bool transpose, const float *value)
210. {
211.     int location = fetchUniformLocation(name);
212.     GL_CALL(glUniformMatrix3fv(location, count, transpose, value));
213. }
215. void ShaderProgram::setUniformMatrix3fv(int location, int count, bool transpose, const float *value)
216. {
217.     GL_CALL(glUniformMatrix3fv(location, count, transpose, value));
218. }
220. void ShaderProgram::setUniformMatrix4fv(const char* name, int count, bool transpose, const float *value)
221. {
222.     int location = fetchUniformLocation(name);
223.     GL_CALL(glUniformMatrix4fv(location, count, transpose, value));
224. }
226. void ShaderProgram::setUniformMatrix4fv(int location, int count, bool transpose, const float *value)
227. {
228.     GL_CALL(glUniformMatrix4fv(location, count, transpose, value));
229. }
231. int ShaderProgram::fetchAttributeLocation(const char* name)
232. {
233.     int location;
234.     auto it = m_attributes.find(name);
235.     if (it == m_attributes.end())
236.     {
237.         GL_CALL(location = glGetAttribLocation(m_program, name));
238.         if (location == -1) {
239.             LOGI("no attribute: %s", name);
240.             //GLInspector::printProgramInfoLog(m_program, "fetchAttributeLocation");
241.             return -1;
242.         }
243.         m_attributes[name] = location;
244.     }
245.     else
246.     {
247.         location = it->second;
248.     }
249.     return location;
250. }
252. int ShaderProgram::fetchUniformLocation(const char* name)
253. {
254.     int location;
255.     auto it = m_uniforms.find(name);
256.     if (it == m_uniforms.end())
257.     {
258.         GL_CALL(location = glGetUniformLocation(m_program, name));
259.         if (location == -1) {
260.             LOGI("no uniform: %s", name);
261.             //GLInspector::printProgramInfoLog(m_program, "fetchUniformLocation");
262.             return -1;
263.         }
264.         m_uniforms[name] = location;
265.     }
266.     else
267.     {
268.         location = it->second;
269.     }
270.     return location;
271. }
273. void ShaderProgram::compileShaders(const char* vertexCode, const char* fragmentCode)
274. {
275.     GLuint vertexShader = loadShader(GL_VERTEX_SHADER, vertexCode);
276.     GLuint fragmentShader = loadShader(GL_FRAGMENT_SHADER, fragmentCode);
277.     m_program = linkProgram(vertexShader, fragmentShader);
278. }
280. GLuint ShaderProgram::loadShader(GLenum type, const char* source)
281. {
282.     GL_CALL(GLuint shader = glCreateShader(type));
283.     GL_CALL(glShaderSource(shader, 1, &source, nullptr));
284.     GL_CALL(glCompileShader(shader));
285.     GLint success;
286.     glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
287.     if (!success) {
288.         GLInspector::printShaderInfoLog(shader, "loadShader");
289.         return 0;
290.     }
291.     return shader;
292. }
294. GLuint ShaderProgram::linkProgram(GLuint vertexShader, GLuint fragmentShader)
295. {
296.     GL_CALL(GLuint program = glCreateProgram());
297.     GL_CALL(glAttachShader(program, vertexShader));
298.     GL_CALL(glAttachShader(program, fragmentShader));
299.     GL_CALL(glLinkProgram(program));
300.     GLint success;
301.     glGetProgramiv(program, GL_LINK_STATUS, &success);
302.     if (!success) {
303.         GLInspector::printProgramInfoLog(m_program, "linkProgram");
304.     }
305.     GL_CALL(glDeleteShader(vertexShader));
306.     GL_CALL(glDeleteShader(fragmentShader));
307.     return program;
308. }
309. } // namespace glcore

复制代码

2.8 VBO

​    VBO 是 Vertex Buffer Object 的简称，即顶点缓冲对象，作用是缓存顶点数据到显存中，避免频繁调用 glVertexAttribPointer 传输顶点数据，减少 CPU 到 GPU 的数据传输，提高渲染效率。
​    顶点属性主要有位置、颜色、纹理坐标、法线、切线、副切线等，每个属性又有属性标识、维数、是否已标准化、数据类型、偏移、别名、纹理单元等。
​    由于 VBO 中有多个属性数据，每个属性有多个字段，笔者除了封装 VertexBufferObject 类，还封装了 VertexAttributes 和 VertexAttribute 两个类。VertexAttribute 是属性描述类，VertexAttributes 是属性描述集合。
​    vertex_buffer_object.h

1. #pragma once
3. #include <initializer_list>
4. #include <vector>
6. #include "core_lib.h"
7. #include "shader_program.h"
8. #include "vertex_attributes.h"
9. #include "vertex_attribute.h"
10. #include "vertex_attributes.h"
12. using namespace std;
14. namespace glcore
15. {
16. /**
17. * 顶点属性缓冲对象 (简称VBO)
18. * @author little fat sheep
19. */
20. class VertexBufferObject
21. {
22. protected:
23.     bool m_isBound = false; // 是否已绑定到VBO (或VAO)
24.     bool m_isDirty = false; // 是否有脏数据 (缓存的数据需要更新)
26. private:
27.     GLuint m_vboHandle; // VBO句柄
28.     VertexAttributes* m_attributes; // 顶点属性
29.     GLuint m_usage; // GL_STATIC_DRAW 或 GL_DYNAMIC_DRAW
30.     const float* m_vertices; // 顶点属性数据
31.     int m_vertexNum = 0; // 顶点个数
32.     int m_bytes = 0; // 顶点属性字节数
34. public:
35.     VertexBufferObject(bool isStatic, initializer_list<VertexAttribute*> attributes);
36.     VertexBufferObject(bool isStatic, VertexAttributes* attributes);
37.     virtual ~VertexBufferObject();
38.     void setVertices(float* vertices, int bytes);
39.     void bind(ShaderProgram* shader);
40.     virtual void bind(ShaderProgram* shader, int* locations);
41.     void unbind(ShaderProgram* shader);
42.     virtual void unbind(ShaderProgram* shader, int* locations);
43.     int getNumVertices() { return m_vertexNum; }
45. private:
46.     void applyBufferData(); // 缓存数据
47. };
48. } // namespace glcore

复制代码

​    vertex_buffer_object.cpp

1. #include
3. #include "glcore/gl_inspector.h"
4. #include "glcore/vertex_buffer_object.h"
6. #define LOG_TAG "Native: VertexBufferObject"
7. #define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
9. namespace glcore
10. {
11. VertexBufferObject::VertexBufferObject(bool isStatic, initializer_list<VertexAttribute*> attributes):
12.     VertexBufferObject(isStatic, new VertexAttributes(attributes))
13. {
14. }
16. VertexBufferObject::VertexBufferObject(bool isStatic, VertexAttributes* attributes):
17.     m_attributes(attributes)
18. {
19.     m_usage = isStatic ? GL_STATIC_DRAW : GL_DYNAMIC_DRAW;
20.     GL_CALL(glGenBuffers(1, &m_vboHandle));
21.     LOGI("init: %d", m_vboHandle);
22. }
24. VertexBufferObject::~VertexBufferObject()
25. {
26.     LOGI("destroy");
27.     GL_CALL(glBindBuffer(GL_ARRAY_BUFFER, 0));
28.     GL_CALL(glDeleteBuffers(1, &m_vboHandle));
29.     m_vboHandle = 0;
30.     delete m_attributes;
31.     delete[] m_vertices;
32. }
34. void VertexBufferObject::setVertices(float* vertices, int bytes)
35. {
36.     m_vertices = vertices;
37.     m_vertexNum = bytes / m_attributes->vertexSize;
38.     m_bytes = bytes;
39.     m_isDirty = true;
40.     if (m_isBound)
41.     {
42.         applyBufferData();
43.     }
44. }
46. void VertexBufferObject::bind(ShaderProgram* shader)
47. {
48.     bind(shader, nullptr);
49. }
51. void VertexBufferObject::bind(ShaderProgram* shader, int* locations)
52. {
53.     GL_CALL(glBindBuffer(GL_ARRAY_BUFFER, m_vboHandle));
54.     if (m_isDirty)
55.     {
56.         applyBufferData();
57.     }
58.     if (locations == nullptr)
59.     {
60.         for (int i = 0; i < m_attributes->size(); i++)
61.         {
62.             VertexAttribute* attribute = m_attributes->get(i);
63.             shader->enableVertexAttribArray(attribute->alias);
64.             shader->setVertexAttribPointer(attribute->alias, attribute->numComponents,
65.                attribute->type, attribute->normalized, m_attributes->vertexSize,
66.                attribute->offset);
67.         }
68.     }
69.     else
70.     {
71.         for (int i = 0; i < m_attributes->size(); i++)
72.         {
73.             VertexAttribute* attribute = m_attributes->get(i);
74.             shader->enableVertexAttribArray(locations[i]);
75.             shader->setVertexAttribPointer(locations[i], attribute->numComponents,
76.                attribute->type, attribute->normalized, m_attributes->vertexSize,
77.                attribute->offset);
78.         }
79.     }
80.     m_isBound = true;
81. }
83. void VertexBufferObject::unbind(ShaderProgram* shader)
84. {
85.     unbind(shader, nullptr);
86. }
88. void VertexBufferObject::unbind(ShaderProgram* shader, int* locations)
89. {
90.     if (locations == nullptr)
91.     {
92.         for (int i = 0; i < m_attributes->size(); i++)
93.         {
94.             shader->disableVertexAttribArray(m_attributes->get(i)->alias);
95.         }
96.     }
97.     else
98.     {
99.         for (int i = 0; i < m_attributes->size(); i++)
100.         {
101.             shader->disableVertexAttribArray(locations[i]);
102.         }
103.     }
104.     m_isBound = false;
105. }
107. void VertexBufferObject::applyBufferData()
108. {
109.     GL_CALL(glBufferData(GL_ARRAY_BUFFER, m_bytes, m_vertices, m_usage));
110.     //GLInspector::checkGLError("vbo: applyBufferData");
111.     m_isDirty = false;
112. }
113. } // namespace glcore

复制代码

​    vertex_attributes.h

1. #pragma once
3. #include <initializer_list>
4. #include <vector>
6. #include "vertex_attribute.h"
8. using namespace std;
10. namespace glcore
11. {
12. /**
13. * 顶点属性集(位置、颜色、纹理坐标、法线、切线、副切线等中的一部分)
14. * 每个顶点属性可以看作一个通道, 这个通道可能是多维的, 每个维度可能是多字节的
15. * @author little fat sheep
16. */
17. class VertexAttributes
18. {
19. public:
20.     int vertexSize; // 所有顶点属性的字节数
22. private:
23.     vector<VertexAttribute*> m_attributes; // 顶点属性列表
25. public:
26.     VertexAttributes(initializer_list<VertexAttribute*> attributes);
27.     ~VertexAttributes();
28.     VertexAttribute* get(int index); // 根据索引获取属性
29.     int size(); // 获取属性个数
31. private:
32.     int calculateOffsets(); // 计算偏移
33. };
35. /**
36. * 顶点属性标识
37. * @author little fat sheep
38. */
39. class Usage {
40. public:
41.     static const int Position = 1;
42.     static const int ColorUnpacked = 2;
43.     static const int ColorPacked = 4;
44.     static const int Normal = 8;
45.     static const int TextureCoordinates = 16;
46.     static const int Tangent = 32;
47.     static const int BiNormal = 64;
48. };
49. } // namespace glcore

复制代码

​    vertex_attributes.cpp

1. #include "glcore/vertex_attributes.h"
3. namespace glcore
4. {
5. VertexAttributes::VertexAttributes(initializer_list<VertexAttribute*> attributes):
6.         m_attributes(attributes)
7. {
8.     vertexSize = calculateOffsets();
9. }
11. VertexAttributes::~VertexAttributes()
12. {
13.     m_attributes.clear();
14. }
16. VertexAttribute* VertexAttributes::get(int index)
17. {
18.     if (index >= 0 && index < m_attributes.size())
19.     {
20.         return m_attributes[index];
21.     }
22.     return nullptr;
23. }
25. int VertexAttributes::size()
26. {
27.     return m_attributes.size();
28. }
30. int VertexAttributes::calculateOffsets() {
31.     int count = 0;
32.     for (VertexAttribute* attribute : m_attributes) {
33.         attribute->offset = count;
34.         count += attribute->getSizeInBytes();
35.     }
36.     return count;
37. }
38. } // namespace glcore

复制代码

​    vertex_attribute.h

1. #pragma once
3. namespace glcore
4. {
5. /**
6. * 单个顶点属性(位置、颜色、纹理坐标、法线、切线、副切线等中的一个)
7. * 每个顶点属性可以看作一个通道, 这个通道可能是多维的, 每个维度可能是多字节的
8. * @author little fat sheep
9. */
10. class VertexAttribute
11. {
12. public:
13.     int usage; // 顶点属性标识
14.     int numComponents; // 顶点属性维数 (如顶点坐标属性是3维的, 纹理坐标是2维的)
15.     bool normalized; // 顶点属性是否已经标准化 (有符号: -1~1, 无符号: 0~1)
16.     int type; // 顶点属性的变量类型 (GL_FLOAT、GL_UNSIGNED_BYTE等)
17.     int offset; // 顶点属性在字节上的偏移
18.     const char* alias; // 顶点属性别名 (着色器中变量名)
19.     int unit; // 纹理单元 (可能有多个纹理, 可选)
21. public:
22.     VertexAttribute(int usage, int numComponents, const char* alias);
23.     VertexAttribute(int usage, int numComponents, const char* alias, int unit);
24.     VertexAttribute(int usage, int numComponents, int type, bool normalized, const char* alias);
25.     VertexAttribute(int usage, int numComponents, int type, bool normalized, const char* alias, int unit);
26.     ~VertexAttribute();
28.     static VertexAttribute* Position(); // 位置参数信息
29.     static VertexAttribute* TexCoords(int unit); // 纹理坐标参数信息
30.     static VertexAttribute* Normal(); // 法线参数信息
31.     static VertexAttribute* ColorPacked(); // 颜色参数信息
32.     static VertexAttribute* ColorUnpacked(); // 颜色参数信息
33.     static VertexAttribute* Tangent(); // 切线参数信息
34.     static VertexAttribute* Binormal(); // 副切线参数信息
36.     int getSizeInBytes(); // 属性对应的字节数
38. private:
39.     void create(int usage, int numComponents, int type, bool normalized, const char* alias, int unit);
40. };
41. } // namespace glcore

复制代码

​    vertex_attribute.cpp

1. #include
2. #include <string>
4. #include "glcore/shader_program.h"
5. #include "glcore/vertex_attribute.h"
6. #include "glcore/vertex_attributes.h"
8. #define LOG_TAG "Native: VertexAttribute"
9. #define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
11. using namespace std;
13. namespace glcore
14. {
15. VertexAttribute::VertexAttribute(int usage, int numComponents, const char* alias):
16.         VertexAttribute(usage, numComponents, alias, 0)
17. {
18. }
20. VertexAttribute::VertexAttribute(int usage, int numComponents, const char* alias, int unit)
21. {
22.     int type = usage == Usage::ColorPacked ? GL_UNSIGNED_BYTE : GL_FLOAT;
23.     bool normalized = usage == Usage::ColorPacked;
24.     create(usage, numComponents, type, normalized, alias, unit);
25. }
27. VertexAttribute::VertexAttribute(int usage, int numComponents, int type, bool normalized, const char* alias)
28. {
29.     create(usage, numComponents, type, normalized, alias, 0);
30. }
32. VertexAttribute::VertexAttribute(int usage, int numComponents, int type, bool normalized, const char* alias, int unit)
33. {
34.     create(usage, numComponents, type, normalized, alias, unit);
35. }
37. VertexAttribute::~VertexAttribute()
38. {
39.     free((void*)alias);
40. }
42. VertexAttribute* VertexAttribute::Position() {
43.     return new VertexAttribute(Usage::Position, 3, ShaderProgram::ATTRIBUTE_POSITION);
44. }
46. VertexAttribute* VertexAttribute::TexCoords(int unit) {
47.     string str = string(ShaderProgram::ATTRIBUTE_TEXCOORD) + to_string(unit);
48.     // 复制字符串, 避免str被回收导致悬垂指针问题, 通过free((void*)alias)释放内存
49.     const char* combined = strdup(str.c_str());
50.     return new VertexAttribute(Usage::TextureCoordinates, 2, combined, unit);
51. }
53. VertexAttribute* VertexAttribute::Normal() {
54.     return new VertexAttribute(Usage::Normal, 3, ShaderProgram::ATTRIBUTE_NORMAL);
55. }
57. VertexAttribute* VertexAttribute::ColorPacked() {
58.     return new VertexAttribute(Usage::ColorPacked, 4, GL_UNSIGNED_BYTE, true, ShaderProgram::ATTRIBUTE_COLOR);
59. }
61. VertexAttribute* VertexAttribute::ColorUnpacked() {
62.     return new VertexAttribute(Usage::ColorUnpacked, 4, GL_FLOAT, false, ShaderProgram::ATTRIBUTE_COLOR);
63. }
65. VertexAttribute* VertexAttribute::Tangent() {
66.     return new VertexAttribute(Usage::Tangent, 3, ShaderProgram::ATTRIBUTE_TANGENT);
67. }
69. VertexAttribute* VertexAttribute::Binormal() {
70.     return new VertexAttribute(Usage::BiNormal, 3, ShaderProgram::ATTRIBUTE_BINORMAL);
71. }
73. int VertexAttribute::getSizeInBytes()
74. {
75.     switch (type) {
76.         case GL_FLOAT:
77.         case GL_FIXED:
78.             return 4 * numComponents;
79.         case GL_UNSIGNED_BYTE:
80.         case GL_BYTE:
81.             return numComponents;
82.         case GL_UNSIGNED_SHORT:
83.         case GL_SHORT:
84.             return 2 * numComponents;
85.     }
86.     return 0;
87. }
89. void VertexAttribute::create(int usage, int numComponents, int type, bool normalized, const char* alias, int unit)
90. {
91.     this->usage = usage;
92.     this->numComponents = numComponents;
93.     this->type = type;
94.     this->normalized = normalized;
95.     this->alias = alias;
96.     this->unit = unit;
97.     LOGI("create, alias: %s", alias);
98. }
99. } // namespace glcore

复制代码

2.9 VAO

​    VAO 是 Vertex Array Object 的简称，即顶点数组对象，作用是缓存顶点属性的指针和描述（或格式）信息，简化顶点属性设置的流程，避免频繁调用 glVertexAttribPointer 设置属性描述（或格式）信息，减少 CPU 与 GPU 的交互，提高渲染效率。
​    vertex_buffer_object_with_vao.h

1. #pragma once
3. #include <initializer_list>
5. #include "core_lib.h"
6. #include "vertex_buffer_object.h"
8. namespace glcore
9. {
10. /**
11. * 携带VAO的顶点属性缓冲对象
12. * @author little fat sheep
13. */
14. class VertexBufferObjectWithVAO : public VertexBufferObject
15. {
16. private:
17.     GLuint m_vaoHandle; // VAO句柄
19. public:
20.     VertexBufferObjectWithVAO(bool isStatic, initializer_list<VertexAttribute*> attributes);
21.     VertexBufferObjectWithVAO(bool isStatic, VertexAttributes* attributes);
22.     ~VertexBufferObjectWithVAO() override;
23.     void bind(ShaderProgram* shader, int* locations) override;
24.     void unbind(ShaderProgram* shader, int* locations) override;
25. };
26. } // namespace glcore

复制代码

​    vertex_buffer_object_with_vao.cpp

1. #include
3. #include "glcore/gl_inspector.h"
4. #include "glcore/vertex_buffer_object_with_vao.h"
6. #define LOG_TAG "Native: VertexBufferObjectWithVAO"
7. #define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
9. namespace glcore
10. {
11. VertexBufferObjectWithVAO::VertexBufferObjectWithVAO(bool isStatic,
12.     initializer_list<VertexAttribute*> attributes):
13.         VertexBufferObjectWithVAO(isStatic, new VertexAttributes(attributes))
14. {
15. }
17. VertexBufferObjectWithVAO::VertexBufferObjectWithVAO(bool isStatic, VertexAttributes* attributes):
18.     VertexBufferObject(isStatic, attributes)
19. {
20.     GL_CALL(glGenVertexArrays(1, &m_vaoHandle));
21.     LOGI("init: %d", m_vaoHandle);
22. }
24. VertexBufferObjectWithVAO::~VertexBufferObjectWithVAO()
25. {
26.     LOGI("destroy");
27.     GL_CALL(glDeleteVertexArrays(1, &m_vaoHandle));
28. }
30. void VertexBufferObjectWithVAO::bind(ShaderProgram* shader, int* locations)
31. {
32.     GL_CALL(glBindVertexArray(m_vaoHandle));
33.     if (m_isDirty)
34.     {
35.         VertexBufferObject::bind(shader, locations);
36.     }
37.     m_isBound = true;
38. }
40. void VertexBufferObjectWithVAO::unbind(ShaderProgram* shader, int* locations)
41. {
42.     GL_CALL(glBindVertexArray(0));
43.     m_isBound = false;
44. }
45. } // namespace glcore

复制代码

2.10 IBO

​    IBO 是 Index Buffer Object 的简称，即索引缓冲对象，作用是缓存顶点索引到显存中，避免频繁调用 glDrawElements 传输顶点索引，减少 CPU 到 GPU 的数据传输，提高渲染效率。由于 IBO 绑定的是 OpenGL ES 状态机的 GL_ELEMENT_ARRAY_BUFFER “插槽”，并且对应的绘制指令又是 glDrawElements （都有 Element），因此 IBO 也被称为 EBO。
​    index_buffer_object.h

1. #pragma once
3. #include "core_lib.h"
5. namespace glcore
6. {
7. /**
8. * 顶点索引缓冲对象 (简称IBO)
9. * @author little fat sheep
10. */
11. class IndexBufferObject
12. {
13. private:
14.     GLuint m_iboHandle; // IBO句柄
15.     GLuint m_usage; // GL_STATIC_DRAW 或 GL_DYNAMIC_DRAW
16.     GLenum m_type = GL_UNSIGNED_SHORT; // 索引数据类型 (GL_UNSIGNED_SHORT 或 GL_UNSIGNED_INT)
17.     const void* m_indices; // 顶点索引数据(short*或int*类型)
18.     int m_indexNum = 0; // 索引个数
19.     int m_bytes = 0; // 顶点索引字节数
20.     bool m_isDirty = false; // 是否有脏数据 (缓存的数据需要更新)
21.     bool m_isBound = false; // 是否已绑定到IBO
23. public:
24.     IndexBufferObject(bool isStatic);
25.     IndexBufferObject(bool isStatic, GLenum type);
26.     ~IndexBufferObject();
27.     void setIndices (void* indices, int bytes);
28.     void setIndices (void* indices, int bytes, GLenum type);
29.     void bind();
30.     void unbind();
31.     int getNumIndices() { return m_indexNum; }
32.     GLenum getType() { return m_type; }
34. private:
35.     void applyBufferData(); // 缓存数据
36.     int getTypeSize(); // 获取type对应的字节数
37. };
38. } // namespace glcore

复制代码

​    index_buffer_object.cpp

1. #include
3. #include "glcore/gl_inspector.h"
4. #include "glcore/index_buffer_object.h"
6. #define LOG_TAG "Native: IndexBufferObject"
7. #define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
9. namespace glcore
10. {
11. IndexBufferObject::IndexBufferObject(bool isStatic):
12.         IndexBufferObject(isStatic, GL_UNSIGNED_SHORT)
13. {
14. }
16. IndexBufferObject::IndexBufferObject(bool isStatic, GLenum type)
17. {
18.     m_usage = isStatic ? GL_STATIC_DRAW : GL_DYNAMIC_DRAW;
19.     m_type = type;
20.     GL_CALL(glGenBuffers(1, &m_iboHandle));
21.     LOGI("init: %d", m_iboHandle);
22. }
24. IndexBufferObject::~IndexBufferObject()
25. {
26.     LOGI("destroy");
27.     GL_CALL(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0));
28.     GL_CALL(glDeleteBuffers(1, &m_iboHandle));
29.     m_iboHandle = 0;
30.     delete[] m_indices;
31. }
33. void IndexBufferObject::setIndices(void* indices, int bytes)
34. {
35.     setIndices(indices, bytes, m_type);
36. }
38. void IndexBufferObject::setIndices(void* indices, int bytes, GLenum type)
39. {
40.     m_indices = indices;
41.     m_type = type;
42.     m_indexNum = bytes > 0 ? bytes / getTypeSize() : 0;
43.     m_bytes = bytes;
44.     m_isDirty = true;
45.     if (m_isBound)
46.     {
47.         applyBufferData();
48.     }
49. }
51. void IndexBufferObject::bind()
52. {
53.     GL_CALL(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_iboHandle));
54.     if (m_isDirty)
55.     {
56.         applyBufferData();
57.     }
58.     m_isBound = true;
59. }
61. void IndexBufferObject::unbind()
62. {
63.     GL_CALL(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0));
64.     m_isBound = false;
65. }
67. void IndexBufferObject::applyBufferData()
68. {
69.     GL_CALL(glBufferData(GL_ELEMENT_ARRAY_BUFFER, m_bytes, m_indices, m_usage));
70.     //GLInspector::checkGLError("ibo: applyBufferData");
71.     m_isDirty = false;
72. }
74. int IndexBufferObject::getTypeSize() {
75.     switch (m_type) {
76.         case GL_UNSIGNED_SHORT:
77.             return 2;
78.         case GL_UNSIGNED_INT:
79.             return 4;
80.     }
81.     return 2;
82. }
83. } // namespace glcore

复制代码

2.11 Mesh

​    Mesh 是网格类，用于管理顶点数据、索引、描述（或格式）等信息，由于 VBO 管理了顶点数据、IBO 管理了顶点索引、VAO 管理了顶点描述（或格式），因此 Mesh 只需管理 VBO、IBO、VAO。另外 IBO 和 VAO 是可选的，Mesh 中需要根据用户的行为调整渲染指令。
​    为方便用户快速创建平面网格，笔者提供了 MeshUtils 类，用户也可以根据该类提供的模板创建自己的网格。
​    mesh.h

1. #pragma once
3. #include <initializer_list>
5. #include "core_lib.h"
6. #include "index_buffer_object.h"
7. #include "shader_program.h"
8. #include "vertex_buffer_object.h"
9. #include "vertex_attribute.h"
10. #include "vertex_attributes.h"
12. using namespace std;
14. namespace glcore
15. {
16. /**
17. * 网格
18. * @author little fat sheep
19. */
20. class Mesh
21. {
22. private:
23.     VertexBufferObject* m_vbo; // 顶点属性缓冲对象
24.     IndexBufferObject* m_ibo; // 顶点索引缓冲对象
25.     GLenum m_mode = GL_TRIANGLES; // 渲染模式 (GL_TRIANGLES、GL_TRIANGLE_STRIP、GL_TRIANGLE_FAN等)
27. public:
28.     Mesh(bool isStatic, initializer_list<VertexAttribute*> attributes);
29.     Mesh(bool isStatic, VertexAttributes* attributes);
30.     Mesh(bool useVao, bool isStatic, initializer_list<VertexAttribute*> attributes);
31.     Mesh(bool useVao, bool isStatic, VertexAttributes* attributes);
32.     ~Mesh();
33.     void setVertices(float* vertices, int bytes); // 设置顶点属性
34.     void setIndices(void* indices, int bytes); // 设置顶点索引
35.     void setIndices(void* indices, int bytes, GLenum type); // 设置顶点索引
36.     void setMode(GLenum mode); // 设置渲染模式
37.     void render(ShaderProgram* shader); // 渲染
38. };
39. } // namespace glcore

复制代码

​    mesh.cpp

1. #include "glcore/gl_inspector.h"
2. #include "glcore/mesh.h"
3. #include "glcore/vertex_buffer_object_with_vao.h"
5. namespace glcore
6. {
7. Mesh::Mesh(bool isStatic, initializer_list<VertexAttribute*> attributes):
8.     Mesh(true, isStatic, new VertexAttributes(attributes))
9. {
10. }
12. Mesh::Mesh(bool isStatic, VertexAttributes* attributes):
13.     Mesh(true, isStatic, attributes)
14. {
15. }
17. Mesh::Mesh(bool useVao, bool isStatic, initializer_list<VertexAttribute*> attributes):
18.     Mesh(useVao, isStatic, new VertexAttributes(attributes))
19. {
20. }
22. Mesh::Mesh(bool useVao, bool isStatic, VertexAttributes* attributes)
23. {
24.     m_vbo = useVao ? new VertexBufferObjectWithVAO(isStatic, attributes) :
25.             new VertexBufferObject(isStatic, attributes);
26.     m_ibo = new IndexBufferObject(isStatic);
27. }
29. Mesh::~Mesh()
30. {
31.     delete m_vbo;
32.     delete m_ibo;
33. }
35. void Mesh::setVertices(float* vertices, int bytes)
36. {
37.     m_vbo->setVertices(vertices, bytes);
38. }
40. void Mesh::setIndices(void* indices, int bytes)
41. {
42.     m_ibo->setIndices(indices, bytes);
43. }
45. void Mesh::setIndices(void* indices, int bytes, GLenum type)
46. {
47.     m_ibo->setIndices(indices, bytes, type);
48. }
50. void Mesh::setMode(GLenum mode)
51. {
52.     m_mode = mode;
53. }
55. void Mesh::render(ShaderProgram* shader)
56. {
57.     m_vbo->bind(shader);
58.     if (m_ibo->getNumIndices() > 0) {
59.         m_ibo->bind();
60.         GL_CALL(glDrawElements(m_mode, m_ibo->getNumIndices(), m_ibo->getType(), nullptr));
61.         m_ibo->unbind();
62.     } else {
63.         GL_CALL(glDrawArrays(m_mode, 0, m_vbo->getNumVertices()));
64.     }
65.     m_vbo->unbind(shader);
66. }
67. } // namespace glcore

复制代码

​    mesh_utils.h

1. #pragma once
3. #include "mesh.h"
5. namespace glcore
6. {
7. /**
8. * 网格工具类
9. * @author little fat sheep
10. */
11. class MeshUtils
12. {
13. public:
14.     static Mesh* createRect(bool reverse);
16. private:
17.     static float* getRectVertices(bool reverse);
18. };
19. } // namespace glcore

复制代码

​    mesh_utils.cpp

1. #include "glcore/mesh_utils.h"
3. namespace glcore
4. {
5. Mesh* MeshUtils::createRect(bool reverse)
6. {
7.     Mesh* mesh = new Mesh(true, {
8.             VertexAttribute::Position(),
9.             VertexAttribute::TexCoords(0)
10.     });
11.     float* vertices = getRectVertices(reverse);
12.     mesh->setVertices(vertices, 4 * 5 * sizeof(float));
13.     void* indices = new short[] { 0, 1, 2, 2, 3, 0 };
14.     mesh->setIndices(indices, 6 * sizeof(short));
15.     return mesh;
16. }
18. float* MeshUtils::getRectVertices(bool reverse)
19. {
20.     if (reverse) {
21.         return new float[] { // 中间渲染(FBO)使用
22.                 -1.0f, -1.0f, 0.0f, 0.0f, 0.0f, // 左下
23.                 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, // 右下
24.                 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, // 右上
25.                 -1.0f, 1.0f, 0.0f, 0.0f, 1.0f // 左上
26.         };
27.     }
28.     return new float[] { // 终端渲染使用
29.             -1.0f, -1.0f, 0.0f, 0.0f, 1.0f, // 左下
30.             1.0f, -1.0f, 0.0f, 1.0f, 1.0f, // 右下
31.             1.0f, 1.0f, 0.0f, 1.0f, 0.0f, // 右上
32.             -1.0f, 1.0f, 0.0f, 0.0f, 0.0f // 左上
33.     };
34. }
35. } // namespace glcore

复制代码

2.12 GLTexture

​    封装 GLTexture 类是了方便用户进行纹理贴图。为了方便管理多渲染目标图层，定义了 TextureAction 接口，并提供 bind 函数，GLTexture、FBO 都继承了 TextureAction，用户自定义的渲染器或特效类也可以继承 TextureAction，将它们统一视为纹理活动（可绑定），这在特效叠加（或后处理）中非常有用，易于扩展。
​    texture_action.h

1. #pragma once
3. #include "core_lib.h"
4. #include "shader_program.h"
6. namespace glcore
7. {
8. /**
9. * 纹理活动 (纹理绑定、FBO绑定)
10. * @author little fat sheep
11. */
12. class TextureAction
13. {
14. public:
15.     virtual ~TextureAction() = default;
16.     virtual void setTexParameter(GLint filter, GLint wrap) {}
17.     virtual void setBindParameter(char* alias, GLenum unit) {}
18.     virtual void bind(ShaderProgram* shader) = 0;
19. };
20. } // namespace glcore

复制代码

​    gl_texture.h

1. #pragma once
3. #include "core_lib.h"
4. #include "shader_program.h"
5. #include "texture_action.h"
7. namespace glcore
8. {
9. /**
10. * 纹理贴图
11. * @author little fat sheep
12. */
13. class GLTexture: public TextureAction
14. {
15. private:
16.     GLuint m_textureHandle = 0; // 纹理句柄
17.     int m_width = 0; // 纹理宽度
18.     int m_height = 0; // 纹理高度
19.     GLint m_filter = GL_LINEAR; // 滤波方式
20.     GLint m_wrap = GL_CLAMP_TO_EDGE; // 环绕方式
21.     const char* m_alias = ShaderProgram::UNIFORM_TEXTURE; // 纹理别名(着色器中变量名)
22.     GLenum m_unit = 0; // 纹理单元 (可能有多个纹理)
23.     bool m_isDirty = false; // 是否有脏数据 (纹理参数需要更新)
25. public:
26.     GLTexture(int width, int height);
27.     GLTexture(void *buffer, int width, int height);
28.     ~GLTexture() override;
29.     void setTexture(const void *buffer);
30.     void setTexParameter(GLint filter, GLint wrap) override;
31.     void setBindParameter(char* alias, GLenum unit) override;
32.     void bind(ShaderProgram* shader) override;
33.     int getWidth() { return m_width; }
34.     int getHeight() { return m_height; }
36. private:
37.     void applyTexParameter();
38. };
39. } // namespace glcore

复制代码

​    gl_texture.cpp

1. #include "glcore/gl_inspector.h"
2. #include "glcore/gl_texture.h"
4. namespace glcore
5. {
6. GLTexture::GLTexture(int width, int height):
7.     m_width(width),
8.     m_height(height)
9. {
10. }
12. GLTexture::GLTexture(void *buffer, int width, int height): GLTexture(width, height)
13. {
14.     setTexture(buffer);
15. }
17. GLTexture::~GLTexture()
18. {
19.     GL_CALL(glBindTexture(GL_TEXTURE_2D, 0));
20.     if (m_textureHandle != 0) {
21.         GL_CALL(glDeleteTextures(1, &m_textureHandle));
22.         m_textureHandle = 0;
23.     }
24. }
26. /**
27. * buffer 可以通过以下两种方式得到
28. * 1) bitmap.copyPixelsToBuffer(bytebuffer);
29. *    void* buffer = env->GetDirectBufferAddress(bytebuffer);
30. * 2) AndroidBitmap_lockPixels(env, bitmap, &buffer)
31. */
32. void GLTexture::setTexture(const void *buffer)
33. {
34.     GL_CALL(glGenTextures(1, &m_textureHandle));
35.     GL_CALL(glBindTexture(GL_TEXTURE_2D, m_textureHandle));
36.     applyTexParameter();
37.     GL_CALL(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_width, m_height, 0,
38.                  GL_RGBA, GL_UNSIGNED_BYTE, buffer));
39.     GL_CALL(glGenerateMipmap(GL_TEXTURE_2D));
40.     GL_CALL(glBindTexture(GL_TEXTURE_2D, 0));
41.     //GLInspector::checkGLError("setTexture");
42. }
44. void GLTexture::setTexParameter(GLint filter, GLint wrap)
45. {
46.     m_filter = filter;
47.     m_wrap = wrap;
48.     m_isDirty = true;
49. }
51. void GLTexture::setBindParameter(char *alias, GLenum unit)
52. {
53.     m_alias = alias;
54.     m_unit = unit;
55. }
57. void GLTexture::bind(ShaderProgram *shader)
58. {
59.     shader->setUniformi(m_alias, m_unit);
60.     GL_CALL(glActiveTexture(GL_TEXTURE0 + m_unit));
61.     GL_CALL(glBindTexture(GL_TEXTURE_2D, m_textureHandle));
62.     if (m_isDirty)
63.     {
64.         applyTexParameter();
65.     }
66. }
68. void GLTexture::applyTexParameter()
69. {
70.     GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, m_filter));
71.     GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, m_filter));
72.     GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, m_wrap));
73.     GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, m_wrap));
74.     m_isDirty = false;
75. }
76. } // namespace glcore

复制代码

2.13 FBO

​    FBO 是 Frame Buffer Object 的简称，即帧缓冲对象，主要用于离屏渲染、特效叠加，
​    frame_buffer_object.h

1. #pragma once
3. #include "core_lib.h"
4. #include "format.h"
5. #include "shader_program.h"
6. #include "texture_action.h"
8. namespace glcore
9. {
10. /**
11. * 帧缓冲对象 (简称FBO, 用于离屏渲染)
12. * @author little fat sheep
13. */
14. class FrameBufferObject: public TextureAction
15. {
16. private:
17.     Format* m_format; // 颜色格式
18.     int m_width; // 缓冲区宽度
19.     int m_height; // 缓冲区高度
20.     bool m_hasDepth; // 是否有深度缓冲区
21.     bool m_hasStencil; // 是否有模板缓冲区
22.     GLuint m_frameBufferHandle; // 帧缓冲区句柄
23.     GLuint m_depthBufferHandle; // 深度缓冲区句柄
24.     GLuint m_stencilBufferHandle; // 模板缓冲区句柄
25.     GLuint m_colorTextureHandle; // 颜色缓冲区句柄
26.     GLint m_preFramebufferHandle; // 前一个帧缓冲区句柄
27.     int m_preFramebufferViewPort[4]; // 前一个帧缓冲区视口
28.     GLint m_filter = GL_LINEAR; // 滤波方式
29.     GLint m_wrap = GL_CLAMP_TO_EDGE; // 环绕方式
30.     const char* m_alias = ShaderProgram::UNIFORM_TEXTURE; // 纹理别名(着色器中变量名)
31.     GLenum m_unit = 0; // 纹理单元 (可能有多个纹理)
32.     bool m_isDirty = true; // 是否有脏数据 (纹理参数需要更新)
34. public:
35.     FrameBufferObject(Format* format, int width, int height, bool hasDepth, bool hasStencil);
36.     ~FrameBufferObject() override;
37.     void setTexParameter(GLint filter, GLint wrap) override;
38.     void setBindParameter(char* alias, GLenum unit) override;
39.     void begin();
40.     void end();
41.     void bind(ShaderProgram* shader) override;
43. private:
44.     void applyTexParameter();
45. };
46. } // namespace glcore

复制代码

​    frame_buffer_object.cpp

1. #include "glcore/frame_buffer_object.h"
2. #include "glcore/gl_inspector.h"
4. namespace glcore
5. {
6. FrameBufferObject::FrameBufferObject(Format* format, int width, int height, bool hasDepth, bool hasStencil)
7. {
8.     m_format = format;
9.     m_width = width;
10.     m_height = height;
11.     m_hasDepth = hasDepth;
12.     m_hasStencil = hasStencil;
13.     GL_CALL(glGenFramebuffers(1, &m_frameBufferHandle));
14.     begin();
15.     if (m_hasDepth)
16.     {
17.         GL_CALL(glGenRenderbuffers(1, &m_depthBufferHandle));
18.         GL_CALL(glBindRenderbuffer(GL_RENDERBUFFER, m_depthBufferHandle));
19.         GL_CALL(glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, width, height));
20.         GL_CALL(glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
21.             GL_RENDERBUFFER, m_depthBufferHandle));
22.         GL_CALL(glBindRenderbuffer(GL_RENDERBUFFER, 0));
23.     }
24.     if (m_hasStencil)
25.     {
26.         GL_CALL(glGenRenderbuffers(1, &m_stencilBufferHandle));
27.         GL_CALL(glBindRenderbuffer(GL_RENDERBUFFER, m_stencilBufferHandle));
28.         GL_CALL(glRenderbufferStorage(GL_RENDERBUFFER, GL_STENCIL_INDEX8, width, height));
29.         GL_CALL(glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT,
30.             GL_RENDERBUFFER, m_stencilBufferHandle));
31.         GL_CALL(glBindRenderbuffer(GL_RENDERBUFFER, 0));
32.     }
33.     GL_CALL(glGenTextures(1, &m_colorTextureHandle));
34.     GL_CALL(glBindTexture(GL_TEXTURE_2D, m_colorTextureHandle));
35.     GL_CALL(glTexImage2D(GL_TEXTURE_2D, 0, m_format->getFormat(), m_width,
36.     m_height, 0, m_format->getFormat(), m_format->getType(), nullptr));
37.     applyTexParameter();
38.     GL_CALL(glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
39.         GL_TEXTURE_2D, m_colorTextureHandle, 0));
40.     end();
41. }
43. FrameBufferObject::~FrameBufferObject()
44. {
45.     GL_CALL(glBindTexture(GL_TEXTURE_2D, 0));
46.     GL_CALL(glDeleteTextures(1, &m_colorTextureHandle));
47.     if (m_hasDepth) {
48.         GL_CALL(glDeleteRenderbuffers(1, &m_depthBufferHandle));
49.     }
50.     if (m_hasStencil) {
51.         GL_CALL(glDeleteRenderbuffers(1, &m_stencilBufferHandle));
52.     }
53.     GL_CALL(glDeleteFramebuffers(1, &m_frameBufferHandle));
54. }
56. void FrameBufferObject::setTexParameter(GLint filter, GLint wrap)
57. {
58.     m_filter = filter;
59.     m_wrap = wrap;
60.     m_isDirty = true;
61. }
63. void FrameBufferObject::setBindParameter(char* alias, GLenum unit)
64. {
65.     m_alias = alias;
66.     m_unit = unit;
67. }
69. void FrameBufferObject::begin()
70. {
71.     GL_CALL(glGetIntegerv(GL_FRAMEBUFFER_BINDING, &m_preFramebufferHandle));
72.     GL_CALL(glGetIntegerv(GL_VIEWPORT, m_preFramebufferViewPort));
73.     GL_CALL(glBindFramebuffer(GL_FRAMEBUFFER, m_frameBufferHandle));
74.     GL_CALL(glViewport(0, 0, m_width, m_height));
75. }
77. void FrameBufferObject::end()
78. {
79.     GL_CALL(glBindFramebuffer(GL_FRAMEBUFFER, m_preFramebufferHandle));
80.     GL_CALL(glViewport(m_preFramebufferViewPort[0], m_preFramebufferViewPort[1],
81.         m_preFramebufferViewPort[2], m_preFramebufferViewPort[3]));
82. }
84. void FrameBufferObject::bind(ShaderProgram* shader)
85. {
86.     shader->setUniformi(m_alias, m_unit);
87.     GL_CALL(glActiveTexture(GL_TEXTURE0 + m_unit));
88.     GL_CALL(glBindTexture(GL_TEXTURE_2D, m_colorTextureHandle));
89.     if (m_isDirty)
90.     {
91.         applyTexParameter();
92.     }
93. }
95. void FrameBufferObject::applyTexParameter()
96. {
97.     GL_CALL(glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, m_filter));
98.     GL_CALL(glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, m_filter));
99.     GL_CALL(glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, m_wrap));
100.     GL_CALL(glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, m_wrap));
101.     m_isDirty = false;
102. }
103. } // namespace glcore

复制代码

​    format.h

1. #pragma once
3. #include "core_lib.h"
5. namespace glcore
6. {
7. /**
8. * 纹理格式
9. * @author little fat sheep
10. */
11. class Format
12. {
13. private:
14.     GLint format;
15.     GLenum type;
17. public:
18.     Format(GLint format, GLenum type);
19.     GLint getFormat() { return format; }
20.     GLenum getType() { return type; }
22.     static Format* Alpha();
23.     static Format* LuminanceAlpha();
24.     static Format* RGB565();
25.     static Format* RGBA4444();
26.     static Format* RGB888();
27.     static Format* RGBA8888();
28. };
29. } // namespace glcore

复制代码

​    format.cpp

1. #include "glcore/format.h"
3. namespace glcore
4. {
5. Format::Format(GLint format, GLenum type):
6.     format(format),
7.     type(type)
8. {
9. }
11. Format *Format::Alpha()
12. {
13.     return new Format(GL_ALPHA, GL_UNSIGNED_BYTE);
14. }
16. Format *Format::LuminanceAlpha()
17. {
18.     return new Format(GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE);
19. }
21. Format *Format::RGB565()
22. {
23.     return new Format(GL_RGB, GL_UNSIGNED_SHORT_5_6_5);
24. }
26. Format *Format::RGBA4444()
27. {
28.     return new Format(GL_RGB, GL_UNSIGNED_SHORT_4_4_4_4);
29. }
31. Format *Format::RGB888()
32. {
33.     return new Format(GL_RGB, GL_UNSIGNED_BYTE);
34. }
36. Format *Format::RGBA8888()
37. {
38.     return new Format(GL_RGBA, GL_UNSIGNED_BYTE);
39. }
40. } // namespace glcore

复制代码

3 JNI 相关

​    本节主要介绍 glcore 框架在初始化过程中所依附的工具类，如 View 载体、字符串加载工具、图片加载工具等，它们与 JNI 密切相关，不便于进行跨平台迁移，因此不能将它们归入 glcore 框架中。
​    如果读者对 JNI 不太熟悉，推荐阅读 → JNI环境搭建、JNI基础语法。
3.1 EGLSurfaceView

​    Android 中渲染内容需要 View 容器承载，有以下常用方案，详见 → 【OpenGL ES】不用GLSurfaceView，如何渲染图像。

• SurfaceView + SurfaceHolder.Callback
  
• TextureView + TextureView.SurfaceTextureListener
  

​    本框架采用 TextureView + TextureView.SurfaceTextureListener 方案，因为它在退后台后不会销毁 Surface，避免反复销毁和创建 Surface，稳定性更好。
​    Java 和 Native 中都有 EGLSurfaceView，它们是相互绑定的，前者为后者提供了 Surface、宽高、Renderer、Context 等属性，并管理了其生命周期。
​    EGLSurfaceView.java

1. package com.zhyan8.egldemo;
3. import android.content.Context;
4. import android.graphics.SurfaceTexture;
5. import android.util.Log;
6. import android.view.Choreographer;
7. import android.view.Surface;
8. import android.view.TextureView;
10. import androidx.annotation.NonNull;
12. /**
13. * @author little fat sheep
14. * 承载EGL环境的View, 类比GLSurfaceView
15. */
16. public class EGLSurfaceView extends TextureView implements TextureView.SurfaceTextureListener {
17.     private static final String TAG = "EGLSurfaceView";
19.     private long mNativeHandle;
20.     protected Surface mSurface;
21.     private Choreographer mChoreographer = Choreographer.getInstance();
23.     static {
24.         System.loadLibrary("egl-native");
25.     }
27.     public EGLSurfaceView(Context context) {
28.         super(context);
29.         setSurfaceTextureListener(this);
30.         mNativeHandle = nativeCreate();
31.     }
33.     public void setRenderer(long handle) {
34.         Log.i(TAG, "setRenderer");
35.         nativeSetRenderer(mNativeHandle, handle);
36.     }
38.     public void startRender() {
39.         Log.i(TAG, "startRender");
40.         mChoreographer.removeFrameCallback(mFrameCallback);
41.         mChoreographer.postFrameCallback(mFrameCallback);
42.     }
44.     public void stopRender() {
45.         Log.i(TAG, "stopRender");
46.         mChoreographer.removeFrameCallback(mFrameCallback);
47.     }
49.     public void requestRender() {
50.         mFrameCallback.doFrame(System.nanoTime());
51.     }
53.     @Override
54.     public void onSurfaceTextureAvailable(@NonNull SurfaceTexture surface, int width, int height) {
55.         Log.i(TAG, "onSurfaceTextureAvailable");
56.         mSurface = new Surface(surface);
57.         nativeSurfaceCreated(mNativeHandle, mSurface);
58.         nativeSurfaceChanged(mNativeHandle, width, height);
59.     }
61.     @Override
62.     public void onSurfaceTextureSizeChanged(@NonNull SurfaceTexture surface, int width, int height) {
63.         Log.i(TAG, "onSurfaceTextureSizeChanged, width=" + width + ", height=" + height);
64.         nativeSurfaceChanged(mNativeHandle, width, height);
65.     }
67.     @Override
68.     public boolean onSurfaceTextureDestroyed(@NonNull SurfaceTexture surface) {
69.         Log.i(TAG, "onSurfaceTextureDestroyed");
70.         nativeSurfaceDestroyed(mNativeHandle);
71.         return false;
72.     }
74.     @Override
75.     public void onSurfaceTextureUpdated(@NonNull SurfaceTexture surface) {
76.     }
78.     @Override
79.     protected void onDetachedFromWindow() {
80.         super.onDetachedFromWindow();
81.         Log.i(TAG, "onDetachedFromWindow");
82.         stopRender();
83.         setSurfaceTextureListener(null);
84.         mSurface.release();
85.         nativeDestroy(mNativeHandle);
86.         mNativeHandle = 0;
87.     }
89.     private Choreographer.FrameCallback mFrameCallback = new Choreographer.FrameCallback() {
90.         @Override
91.         public void doFrame(long frameTimeNanos) {
92.             mChoreographer.postFrameCallback(this);
93.             nativeDrawFrame(mNativeHandle);
94.         }
95.     };
97.     private native long nativeCreate();
98.     private native void nativeSetRenderer(long viewHandle, long rendererHandle);
99.     private native void nativeSurfaceCreated(long handle, Object surface);
100.     private native void nativeSurfaceChanged(long handle, int width, int height);
101.     private native void nativeDrawFrame(long handle);
102.     private native void nativeSurfaceDestroyed(long handle);
103.     private native void nativeDestroy(long handle);
104. }

复制代码

​    jin_egl_surface_view.cpp

1. #include
2. #include
3. #include
4. #include <jni.h>
6. #include "glcore/core.h"
8. #define LOG_TAG "JNIBrige_EGLSurfaceView"
9. #define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
11. using namespace glcore;
13. static jlong nativeCreate(JNIEnv *env, jobject thiz)
14. {
15.     LOGI("nativeCreate");
16.     EGLSurfaceView* view = new EGLSurfaceView();
17.     return reinterpret_cast<jlong>(view);
18. }
20. static void nativeSetRenderer(JNIEnv *env, jobject thiz, jlong viewHandle, jlong rendererHandle)
21. {
22.     LOGI("nativeSetRenderer");
23.     EGLSurfaceView* view = reinterpret_cast<EGLSurfaceView*>(viewHandle);
24.     EGLSurfaceView::Renderer* renderer = reinterpret_cast<EGLSurfaceView::Renderer*>(rendererHandle);
25.     view->setRenderer(renderer);
26. }
28. static void nativeSurfaceCreated(JNIEnv* env, jobject thiz, jlong handle, jobject surface)
29. {
30.     LOGI("nativeSurfaceCreated");
31.     EGLSurfaceView* view = reinterpret_cast<EGLSurfaceView*>(handle);
32.     ANativeWindow* window = ANativeWindow_fromSurface(env, surface);
33.     app->setWindow(window);
34.     view->surfaceCreated();
35. }
37. static void nativeSurfaceChanged(JNIEnv* env, jobject thiz, jlong handle, jint width, jint height)
38. {
39.     LOGI("nativeSurfaceChanged");
40.     EGLSurfaceView* view = reinterpret_cast<EGLSurfaceView*>(handle);
41.     view->surfaceChanged(width, height);
42. }
44. static void nativeDrawFrame(JNIEnv* env, jobject thiz, jlong handle)
45. {
46.     EGLSurfaceView* view = reinterpret_cast<EGLSurfaceView*>(handle);
47.     view->drawFrame();
48. }
50. static void nativeSurfaceDestroyed(JNIEnv* env, jobject thiz, jlong handle)
51. {
52.     LOGI("nativeSurfaceDestroyed");
53.     EGLSurfaceView* view = reinterpret_cast<EGLSurfaceView*>(handle);
54.     view->surfaceDestroy();
55. }
57. static void nativeDestroy(JNIEnv* env, jobject thiz, jlong handle)
58. {
59.     LOGI("nativeDestroy");
60.     EGLSurfaceView* view = reinterpret_cast<EGLSurfaceView*>(handle);
61.     delete view;
62. }
64. static JNINativeMethod methods[] = {
65.         { "nativeCreate", "()J", (void*) nativeCreate },
66.         { "nativeSetRenderer", "(JJ)V", (void*) nativeSetRenderer },
67.         { "nativeSurfaceCreated", "(JLjava/lang/Object;)V", (void*) nativeSurfaceCreated },
68.         { "nativeSurfaceChanged", "(JII)V", (void*) nativeSurfaceChanged },
69.         { "nativeDrawFrame", "(J)V", (void*) nativeDrawFrame },
70.         { "nativeSurfaceDestroyed", "(J)V", (void*) nativeSurfaceDestroyed },
71.         { "nativeDestroy", "(J)V", (void*) nativeDestroy },
72. };
74. static int registerNativeMethods(JNIEnv* env) {
75.     int result = -1;
76.     jclass clazz = env->FindClass("com/zhyan8/egldemo/EGLSurfaceView");
77.     if (clazz != NULL) {
78.         jint len = sizeof(methods) / sizeof(methods[0]);
79.         if (env->RegisterNatives(clazz, methods, len) == JNI_OK) {
80.             result = 0;
81.         }
82.     }
83.     return result;
84. }
86. jint JNI_OnLoad(JavaVM* vm, void* reserved) {
87.     JNIEnv* env = NULL;
88.     jint result = -1;
89.     if (vm->GetEnv((void**) &env, JNI_VERSION_1_6) == JNI_OK) {
90.         if (NULL != env && registerNativeMethods(env) == 0) {
91.             result = JNI_VERSION_1_6;
92.         }
93.     }
94.     return result;
95. }

复制代码

3.2 StringUtils

​    StringUtils 用于加载顶点和片元着色器资源为字符串。
​    StringUtils.java

1. package com.zhyan8.egldemo;
3. import android.content.Context;
4. import android.util.Log;
6. import java.io.BufferedReader;
7. import java.io.IOException;
8. import java.io.InputStream;
9. import java.io.InputStreamReader;
11. /**
12. * 字符串工具类
13. * @author little fat sheep
14. */
15. public class StringUtils {
16.     private static final String TAG = "BitmapUtils";
18.     /**
19.      * 根据资源路径读取字符串
20.      * @param assetPath 资源路径, 如: "jelly_vert.glsl"
21.      */
22.     public static String loadStringFromAsset(Context context, String assetPath) {
23.         String str = "";
24.         try (InputStream inputStream = context.getAssets().open(assetPath)) {
25.             str = loadString(inputStream);
26.         } catch (IOException e) {
27.             Log.w(TAG, "loadString error, message=" + e.getMessage());
28.         }
29.         return str;
30.     }
32.     /**
33.      * 根据资源id读取字符串
34.      * @param rawId 资源id, 如: "R.raw.vertex_shader"
35.      */
36.     public static String loadStringFromRaw(Context context, String rawId) {
37.         if (rawId.startsWith("R.raw.")) {
38.             rawId = rawId.substring(6); // Remove "R.raw."
39.         }
40.         int id = context.getResources().getIdentifier(rawId, "raw", context.getPackageName());
41.         if (id == 0) {
42.             Log.e(TAG, "loadBitmapFromRaw, resource is not found, rawId=" + rawId);
43.             return null;
44.         }
45.         return loadStringFromRaw(context, id);
46.     }
48.     /**
49.      * 根据资源id读取字符串
50.      * @param rawId 资源id, 如: R.raw.vertex_shader
51.      */
52.     public static String loadStringFromRaw(Context context, int rawId) {
53.         String str = "";
54.         try (InputStream inputStream = context.getResources().openRawResource(rawId)) {
55.             str = loadString(inputStream);
56.         } catch (IOException e) {
57.             Log.w(TAG, "loadString error, message=" + e.getMessage());
58.         }
59.         return str;
60.     }
62.     private static String loadString(InputStream inputStream) {
63.         StringBuilder sb = new StringBuilder();
64.         try (BufferedReader br = new BufferedReader(new InputStreamReader(inputStream))) {
65.             String line;
66.             while ((line = br.readLine()) != null) {
67.                 sb.append(line).append("\n");
68.             }
69.         } catch (IOException e) {
70.             Log.w(TAG, "loadString error, message=" + e.getMessage());
71.         }
72.         return sb.toString();
73.     }
74. }

复制代码

​    string_utils.h

1. #pragma once
3. /**
4. * String工具类
5. * @author little fat sheep
6. */
7. class StringUtils
8. {
9. public:
10.     /**
11.      * 根据资源路径读取字符串
12.      * @param asset 资源路径, 如: "vertex_shader.glsl"
13.      */
14.     static const char* loadStringFromAsset(const char* asset);
16.     /**
17.      * 根据资源id读取字符串
18.      * @param rawId 资源id, 如: "R.raw.vertex_shader"
19.      */
20.     static const char* loadStringFromRaw(const char* rawId);
21. };

复制代码

​    string_utils.cpp

1. #include <jni.h>
3. #include "glcore/core.h"
4. #include "jni/jni_refs.h"
5. #include "jni/string_utils.h"
7. using namespace glcore;
9. const char* StringUtils::loadStringFromAsset(const char* asset)
10. {
11.     JNIEnv* env = app->jniEnv;
12.     jobject context = app->context;
13.     jstring assetStr = env->NewStringUTF(asset);
14.     jclass clazz = env->FindClass("com/zhyan8/egldemo/StringUtils");
15.     jmethodID method = LoadStringFromAssetMethodId(env);
16.     jstring jstr = (jstring) env->CallStaticObjectMethod(clazz, method, context, assetStr);
17.     const char* str = env->GetStringUTFChars(jstr, nullptr);
18.     return str;
19. }
21. const char* StringUtils::loadStringFromRaw(const char* rawId)
22. {
23.     JNIEnv* env = app->jniEnv;
24.     jobject context = app->context;
25.     jstring rawIdStr = env->NewStringUTF(rawId);
26.     jclass clazz = env->FindClass("com/zhyan8/egldemo/StringUtils");
27.     jmethodID method = LoadStringFromRawMethodId(env);
28.     jstring jstr = (jstring) env->CallStaticObjectMethod(clazz, method, context, rawIdStr);
29.     const char* str = env->GetStringUTFChars(jstr, nullptr);
30.     return str;
31. }

复制代码

3.3 BitmapUtils

​    BitmapUtils 用于加载图片资源为位图。
​    BitmapUtils.java

1. package com.zhyan8.egldemo;
3. import android.content.Context;
4. import android.graphics.Bitmap;
5. import android.graphics.BitmapFactory;
6. import android.util.Log;
8. import java.io.IOException;
9. import java.io.InputStream;
11. /**
12. * Bitmap工具类
13. * @author little fat sheep
14. */
15. public class BitmapUtils {
16.     private static final String TAG = "BitmapUtils";
18.     /**
19.      * 根据资源路径读取bitmap
20.      * @param assetPath 资源路径, 如: "textures/xxx.jpg"
21.      */
22.     public static Bitmap loadBitmapFromAsset(Context context, String assetPath) {
23.         Bitmap bitmap = null;
24.         try (InputStream inputStream = context.getAssets().open(assetPath)) {
25.             BitmapFactory.Options options = getOptions();
26.             bitmap = BitmapFactory.decodeStream(inputStream, null, options);
27.         } catch (IOException e) {
28.             Log.e(TAG, "loadBitmapFromAsset error, message=" + e.getMessage());
29.         }
30.         return bitmap;
31.     }
33.     /**
34.      * 根据资源id读取bitmap
35.      * @param rawId 资源id, 如: "R.raw.xxx"
36.      */
37.     public static Bitmap loadBitmapFromRaw(Context context, String rawId) {
38.         if (rawId.startsWith("R.raw.")) {
39.             rawId = rawId.substring(6); // Remove "R.raw."
40.         }
41.         int id = context.getResources().getIdentifier(rawId, "raw", context.getPackageName());
42.         if (id == 0) {
43.             Log.e(TAG, "loadBitmapFromRaw, resource is not found, rawId=" + rawId);
44.             return null;
45.         }
46.         return loadBitmapFromRaw(context, id);
47.     }
49.     /**
50.      * 根据资源id读取bitmap
51.      * @param rawId 资源id, 如: R.raw.xxx
52.      */
53.     public static Bitmap loadBitmapFromRaw(Context context, int rawId) {
54.         Bitmap bitmap = null;
55.         try (InputStream inputStream = context.getResources().openRawResource(rawId)) {
56.             BitmapFactory.Options options = getOptions();
57.             bitmap = BitmapFactory.decodeStream(inputStream, null, options);
58.         } catch (IOException e) {
59.             Log.e(TAG, "loadBitmapFromRaw error, message=" + e.getMessage());
60.         }
61.         return bitmap;
62.     }
64.     private static BitmapFactory.Options getOptions() {
65.         BitmapFactory.Options options = new BitmapFactory.Options();
66.         options.inScaled = false;
67.         return options;
68.     }
69. }

复制代码

​    bitmap_utils.h

1. #pragma once
3. #include <jni.h>
5. struct BitmapData
6. {
7.     void* buffer;
8.     int width;
9.     int height;
10. };
12. /**
13. * Bitmap工具类
14. * @author little fat sheep
15. */
16. class BitmapUtils
17. {
18. public:
19.     /**
20.     * 根据资源路径读取bitmap
21.     * @param asset 资源路径, 如: "textures/xxx.jpg"
22.     */
23.     static BitmapData* loadBitmapDataFromAsset(const char* asset);
25.     /**
26.      * 根据资源id读取bitmap
27.      * @param rawId 资源id, 如: "R.raw.xxx"
28.      */
29.     static BitmapData* loadBitmapDataFromRaw(const char* rawId);
31. private:
32.     static jobject loadBitmapFromAsset(JNIEnv* env, jobject context, const char* asset);
33.     static jobject loadBitmapFromRaw(JNIEnv* env, jobject context, const char* rawId);
34.     static BitmapData* getBitmapData(JNIEnv* env, jobject bitmap);
35. };

复制代码

​    bitmap_utils.cpp

1. #include
2. #include
3. #include <string>
5. #include "glcore/core.h"
6. #include "jni/bitmap_utils.h"
7. #include "jni/jni_refs.h"
9. #define LOG_TAG "Native: BitmapUtils"
10. #define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
12. using namespace glcore;
14. BitmapData* BitmapUtils::loadBitmapDataFromAsset(const char* asset) {
15.     JNIEnv* env = app->jniEnv;
16.     jobject context = app->context;
17.     jobject bitmap = loadBitmapFromAsset(env, context, asset);
18.     if (!bitmap) {
19.         LOGI("loadBitmapDataFromAsset, bitmap is null: %s", asset);
20.         return nullptr;
21.     }
22.     return getBitmapData(env, bitmap);
23. }
25. BitmapData* BitmapUtils::loadBitmapDataFromRaw(const char* rawId)
26. {
27.     JNIEnv* env = app->jniEnv;
28.     jobject context = app->context;
29.     jobject bitmap = loadBitmapFromRaw(env, context, rawId);
30.     if (!bitmap) {
31.         LOGI("loadBitmapDataFromRaw, bitmap is null: %s", rawId);
32.         return nullptr;
33.     }
34.     return getBitmapData(env, bitmap);
35. }
37. jobject BitmapUtils::loadBitmapFromAsset(JNIEnv* env, jobject context, const char* asset)
38. {
39.     jstring assetStr = env->NewStringUTF(asset);
40.     jclass clazz = env->FindClass("com/zhyan8/egldemo/BitmapUtils");
41.     jmethodID method = LoadBitmapFromAssetMethodId(env);
42.     jobject bitmap = env->CallStaticObjectMethod(clazz, method, context, assetStr);
43.     return bitmap;
44. }
46. jobject BitmapUtils::loadBitmapFromRaw(JNIEnv* env, jobject context, const char* rawId)
47. {
48.     jstring rawIdStr = env->NewStringUTF(rawId);
49.     jclass clazz = env->FindClass("com/zhyan8/egldemo/BitmapUtils");
50.     jmethodID method = LoadBitmapFromRawMethodId(env);
51.     jobject bitmap = env->CallStaticObjectMethod(clazz, method, context, rawIdStr);
52.     return bitmap;
53. }
55. BitmapData* BitmapUtils::getBitmapData(JNIEnv* env, jobject bitmap)
56. {
57.     AndroidBitmapInfo info;
58.     if (AndroidBitmap_getInfo(env, bitmap, &info))
59.     {
60.         LOGI("getBitmapData, failed to get bitmap info");
61.         return nullptr;
62.     }
63.     void* buffer;
64.     if (AndroidBitmap_lockPixels(env, bitmap, &buffer)) {
65.         LOGI("getBitmapData, failed to lock bitmap pixels");
66.         return nullptr;
67.     }
68.     BitmapData* data = new BitmapData();
69.     data->buffer = buffer;
70.     data->width = info.width;
71.     data->height = info.height;
72.     return data;
73. }

复制代码

3.4 jin_ref

​    jni_ref 提供了 StringUtils 和 BitmaUtils 的类路径、函数名、函数签名等信息。
​    jni_ref.h

1. #pragma once
3. #include <jni.h>
5. jmethodID LoadBitmapFromAssetMethodId(JNIEnv* env);
6. jmethodID LoadBitmapFromRawMethodId(JNIEnv* env);
7. jmethodID LoadStringFromAssetMethodId(JNIEnv* env);
8. jmethodID LoadStringFromRawMethodId(JNIEnv* env);
9. jmethodID GetMethodId(JNIEnv* env, const char* method[]);
10. jmethodID GetStaticMethodId(JNIEnv* env, const char* method[]);

复制代码

​    jni_ref.c

1. #include "jni/jni_refs.h"
3. const char* loadBitmapFromAssetTab[] = {
4.         "com/zhyan8/egldemo/BitmapUtils",
5.         "loadBitmapFromAsset",
6.         "(Landroid/content/Context;Ljava/lang/String;)Landroid/graphics/Bitmap;"
7. };
9. const char* loadBitmapFromRawTab[] = {
10.         "com/zhyan8/egldemo/BitmapUtils",
11.         "loadBitmapFromRaw",
12.         "(Landroid/content/Context;Ljava/lang/String;)Landroid/graphics/Bitmap;"
13. };
15. const char* loadStringFromAssetTab[] = {
16.         "com/zhyan8/egldemo/StringUtils",
17.         "loadStringFromAsset",
18.         "(Landroid/content/Context;Ljava/lang/String;)Ljava/lang/String;"
19. };
21. const char* loadStringFromRawTab[] = {
22.         "com/zhyan8/egldemo/StringUtils",
23.         "loadStringFromRaw",
24.         "(Landroid/content/Context;Ljava/lang/String;)Ljava/lang/String;"
25. };
27. jmethodID LoadBitmapFromAssetMethodId(JNIEnv* env)
28. {
29.     return GetStaticMethodId(env, loadBitmapFromAssetTab);
30. }
32. jmethodID LoadBitmapFromRawMethodId(JNIEnv* env)
33. {
34.     return GetStaticMethodId(env, loadBitmapFromRawTab);
35. }
37. jmethodID LoadStringFromAssetMethodId(JNIEnv* env)
38. {
39.     return GetStaticMethodId(env, loadStringFromAssetTab);
40. }
42. jmethodID LoadStringFromRawMethodId(JNIEnv* env)
43. {
44.     return GetStaticMethodId(env, loadStringFromRawTab);
45. }
47. jmethodID GetMethodId(JNIEnv* env, const char* method[])
48. {
49.     jclass clazz = env->FindClass(method[0]);
50.     return env->GetMethodID(clazz, method[1], method[2]);
51. }
53. jmethodID GetStaticMethodId(JNIEnv* env, const char* method[])
54. {
55.     jclass clazz = env->FindClass(method[0]);
56.     return env->GetStaticMethodID(clazz, method[1], method[2]);
57. }

复制代码

4 应用

​    本节将基于 glcore 框架写一个色散特效叠加果冻特效的 Demo，体验一下 glcore 的便捷之处。
4.1 MyRenderer

​    my_renderer.h

1. #pragma once
3. #include "glcore/core.h"
4. #include "dispersion_effect.h"
5. #include "jelly_effect.h"
7. using namespace glcore;
9. /**
10. * 自定义渲染器
11. * @author little fat sheep
12. */
13. class MyRenderer : public EGLSurfaceView::Renderer
14. {
15. private:
16.     DispersionEffect* m_dispersionEffect;
17.     JellyEffect* m_jellyEffect;
18.     long m_startTime = 0;
19.     float m_runTime = 0.0f;
21. public:
22.     MyRenderer();
23.     ~MyRenderer() override;
24.     void onSurfaceCreated() override;
25.     void onSurfaceChanged(int width, int height) override;
26.     void onDrawFrame() override;
28. private:
29.     long getTimestamp();
30. };

复制代码

​    my_renderer.cpp

1. #include
2. #include <chrono>
4. #include "custom/my_renderer.h"
6. #define LOG_TAG "Native: MyRenderer"
7. #define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
9. using namespace glcore;
10. using namespace std::chrono;
12. MyRenderer::MyRenderer()
13. {
14.     LOGI("init");
15.     m_dispersionEffect = new DispersionEffect();
16.     m_jellyEffect = new JellyEffect();
17.     m_jellyEffect->setTexAction(m_dispersionEffect);
18. }
20. MyRenderer::~MyRenderer()
21. {
22.     LOGI("destroy");
23.     delete m_dispersionEffect;
24.     delete m_jellyEffect;
25. }
27. void MyRenderer::onSurfaceCreated()
28. {
29.     LOGI("onSurfaceCreated");
30.     m_dispersionEffect->onCreate();
31.     m_jellyEffect->onCreate();
32.     GL_CALL(glClearColor(0.1f, 0.2f, 0.3f, 0.4f));
33.     m_startTime = getTimestamp();
34. }
36. void MyRenderer::onSurfaceChanged(int width, int height)
37. {
38.     LOGI("onSurfaceChanged, width: %d, height: %d", width, height);
39.     GL_CALL(glViewport(0, 0, width, height));
40.     m_dispersionEffect->onResize(width, height);
41.     m_jellyEffect->onResize(width, height);
42. }
44. void MyRenderer::onDrawFrame()
45. {
46.     m_runTime = (getTimestamp() - m_startTime) / 1000.0f;
47.     GL_CALL(glClear(GL_COLOR_BUFFER_BIT));
48.     m_dispersionEffect->onDraw(m_runTime);
49.     m_jellyEffect->onDraw(m_runTime);
50. }
52. long MyRenderer::getTimestamp()
53. {
54.     auto now = std::chrono::system_clock::now(); // 获取当前时间
55.     auto duration = now.time_since_epoch(); // 转换为自纪元以来的时间
56.     return duration_cast<milliseconds>(duration).count();
57. }

复制代码

4.2 DispersionEffect

​    DispersionEffect 是色散特效。
​    dispersion_effect.h

1. #pragma once
3. #include "glcore/core.h"
5. using namespace glcore;
7. /**
8. * 色散特效
9. * @author little fat sheep
10. */
11. class DispersionEffect: public TextureAction
12. {
13. private:
14.     ShaderProgram* m_program;
15.     Mesh* m_mesh;
16.     GLTexture* m_glTexture;
17.     FrameBufferObject* m_fbo;
19. public:
20.     DispersionEffect();
21.     ~DispersionEffect() override;
22.     void onCreate();
23.     void onResize(int width, int height);
24.     void onDraw(float runtime);
25.     void bind(ShaderProgram* shader) override;
27. private:
28.     void createProgram();
29.     void createTexture();
30. };

复制代码

​    dispersion_effect.cpp

1. #include
3. #include "custom/dispersion_effect.h"
4. #include "jni/bitmap_utils.h"
5. #include "jni/string_utils.h"
7. #define LOG_TAG "Native: DispersionEffect"
8. #define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
10. using namespace glcore;
12. DispersionEffect::DispersionEffect()
13. {
14.     LOGI("init");
15. }
17. DispersionEffect::~DispersionEffect()
18. {
19.     LOGI("destroy");
20.     delete m_program;
21.     delete m_mesh;
22.     delete m_glTexture;
23.     delete m_fbo;
24. }
26. void DispersionEffect::onCreate()
27. {
28.     LOGI("onCreate");
29.     createProgram();
30.     createTexture();
31.     m_mesh = MeshUtils::createRect(true);
32.     m_fbo = new FrameBufferObject(Format::RGBA8888(), app->width, app->height, false, false);
33. }
35. void DispersionEffect::onResize(int width, int height)
36. {
37.     LOGI("onResize, width: %d, height: %d", width, height);
38. }
40. void DispersionEffect::onDraw(float runtime)
41. {
42.     m_fbo->begin();
43.     m_program->bind();
44.     m_program->setUniformf("u_time", runtime);
45.     m_program->setUniformf("u_aspect", app->aspect);
46.     m_glTexture->bind(m_program);
47.     m_mesh->render(m_program);
48.     m_fbo->end();
49. }
51. void DispersionEffect::bind(ShaderProgram* shader)
52. {
53.     m_fbo->bind(shader);
54. }
56. void DispersionEffect::createProgram()
57. {
58.     LOGI("createProgram");
59.     const char* vertexCode = StringUtils::loadStringFromAsset("dispersion_vert.glsl");
60.     const char* fragmentCode = StringUtils::loadStringFromAsset("dispersion_frag.glsl");
61.     m_program = new ShaderProgram(vertexCode, fragmentCode);
62. }
64. void DispersionEffect::createTexture()
65. {
66.     LOGI("createTexture");
67.     BitmapData* data = BitmapUtils::loadBitmapDataFromAsset("girl.jpg");
68.     m_glTexture = new GLTexture(data->buffer, data->width, data->height);
69. }

复制代码

​    dispersion_vert.glsl

1. attribute vec4 a_position;
2. attribute vec2 a_texCoord0;
4. varying vec2 v_texCoord;
6. void main() {
7.      gl_Position = a_position;
8.      v_texCoord = a_texCoord0;
9. }

复制代码

​    dispersion_frag.glsl

1. precision highp float;
3. uniform float u_aspect;
4. uniform float u_time;
5. uniform sampler2D u_texture;
7. varying vec2 v_texCoord;
9. vec2 getOffset() { // 偏移函数
10.      float time = u_time * 1.5;
11.      vec2 dire = vec2(sin(time), cos(time));
12.      float strength = sin(u_time * 2.0) * 0.004;
13.      return dire * strength * vec2(1.0, 1.0 / u_aspect);
14. }
16. void main() {
17.      vec2 offset = getOffset();
18.      vec4 color = texture2D(u_texture, v_texCoord);
19.      color.r = texture2D(u_texture, v_texCoord + offset).r;
20.      color.b = texture2D(u_texture, v_texCoord - offset).b;
21.      gl_FragColor = color;
22. }

复制代码

4.3 JellyEffect

​    JellyEffect 是果冻特效。
​    jelly_effect.h

1. #pragma once
3. #include "glcore/core.h"
5. using namespace glcore;
7. /**
8. * 果冻特效
9. * @author little fat sheep
10. */
11. class JellyEffect
12. {
13. private:
14.     ShaderProgram* m_program;
15.     Mesh* m_mesh;
16.     TextureAction* m_texAction;
18. public:
19.     JellyEffect();
20.     ~JellyEffect();
21.     void setTexAction(TextureAction* texAction);
22.     void onCreate();
23.     void onResize(int width, int height);
24.     void onDraw(float runtime);
26. private:
27.     void createProgram();
28. };

复制代码

​    jelly_effect.cpp

1. #include
3. #include "custom/jelly_effect.h"
4. #include "jni/bitmap_utils.h"
5. #include "jni/string_utils.h"
7. #define LOG_TAG "Native: JellyEffect"
8. #define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
10. using namespace glcore;
12. JellyEffect::JellyEffect()
13. {
14.     LOGI("init");
15. }
17. JellyEffect::~JellyEffect()
18. {
19.     LOGI("destroy");
20.     delete m_program;
21.     delete m_mesh;
22. }
24. void JellyEffect::setTexAction(TextureAction* texAction)
25. {
26.     m_texAction = texAction;
27. }
29. void JellyEffect::onCreate()
30. {
31.     LOGI("onCreate");
32.     createProgram();
33.     m_mesh = MeshUtils::createRect(false);
34. }
36. void JellyEffect::onResize(int width, int height)
37. {
38.     LOGI("onResize, width: %d, height: %d", width, height);
39. }
41. void JellyEffect::onDraw(float runtime)
42. {
43.     m_program->bind();
44.     m_program->setUniformf("u_time", runtime);
45.     m_program->setUniformf("u_aspect", app->aspect);
46.     m_texAction->bind(m_program);
47.     m_mesh->render(m_program);
48. }
50. void JellyEffect::createProgram()
51. {
52.     LOGI("createProgram");
53.     const char* vertexCode = StringUtils::loadStringFromAsset("jelly_vert.glsl");
54.     const char* fragmentCode = StringUtils::loadStringFromAsset("jelly_frag.glsl");
55.     m_program = new ShaderProgram(vertexCode, fragmentCode);
56. }

复制代码

​    jelly_vert.glsl

1. attribute vec4 a_position;
2. attribute vec2 a_texCoord0;
4. varying vec2 v_texCoord;
6. void main() {
7.      gl_Position = a_position;
8.      v_texCoord = a_texCoord0;
9. }

复制代码

​    jelly_frag.glsl

1. precision highp float;
3. uniform float u_aspect;
4. uniform float u_time;
5. uniform sampler2D u_texture;
7. varying vec2 v_texCoord;
9. vec2 fun(vec2 center, vec2 uv) { // 畸变函数
10.      vec2 dire = normalize(uv - center);
11.      float dist = distance(uv, center);
12.      vec2 uv1 = uv + sin(dist * 2.2 + u_time * 3.5) * 0.025;
13.      return uv1;
14. }
16. void main() {
17.      vec2 uv = vec2(v_texCoord.x, v_texCoord.y / u_aspect);
18.      vec2 center = vec2(0.5, 0.5 / u_aspect);
19.      vec2 uv1 = fun(center, uv);
20.      uv1.y *= u_aspect;
21.      gl_FragColor = texture2D(u_texture, uv1);
22. }

复制代码

4.4 运行效果

​    运行效果如下，可以看到叠加了色散和果冻特效。

​    声明：本文转自【OpenGL ES】在Android上手撕一个mini版的渲染框架。

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！