登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 业界 ›【OpenGL ES】在Windows上手撕一个mini版的渲染框架 ...

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

卢莹洁 前天 11:20
1 前言

1.1 开发该框架的动机

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

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

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

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

​    本框架具有以下优势。

  • 封装友好：对常用的 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。Windows 上 OpenGL 环境搭建主要有 GLFW / freeglut + Glad / GLEW 方案，详见 → Windows上OpenGL环境搭建，本文采用目前广泛使用的 GLFW + Glad 方案。Android 版本的 glcore 实现详见 → 在Android上手撕一个mini版的渲染框架。
​    本文完整资源（包含 glcore 框架和第 4 节的应用）详见 →【OpenGL ES】一个mini版的Windows渲染框架。
2.1 框架结构

2.png

2.2 CMakeLists

​    CMakeLists.txt
  1. # 设置库名
  2. set(LIB_GL_CORE_NAME "glcore")
  4. # 递归添加源文件列表
  5. file(GLOB_RECURSE GL_CORE_SOURCES ./src/ *.cpp)
  7. # 添加预构建库
  8. add_library(${LIB_GL_CORE_NAME} ${GL_CORE_SOURCES})
  10. # 将当前目录设为公共头文件目录 (任何链接glcore库的目标都能自动获得这个头文件路径)
  11. target_include_directories(${LIB_GL_CORE_NAME} PUBLIC ./)
复制代码
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 <glad/glad.h>
  12. #include <GLFW/glfw3.h>
复制代码
​    之所以要单独拎出 core_lib.h，是为了方便将该框架迁移到其他平台，如 Android 上依赖的三方渲染库是 EGL + GLESv3，如果不抽出 core_lib.h，就需要将很多地方的 glfw3.h + glad.h 改为 egl.h + gl3.h ，工作量大，也容易漏改。另外，还可以很方便地替换渲染环境，如将 glfw3.h + glad.h 替换为 freeglut.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 接口外），如：m_window 是 Windows 特有的，如果将 glcore 迁移到 Android 中，就需要将该变量替换为 ANativeWindow* 类型，将这些平台相关变量都集中在 Application 中，迁移平台时修改起来也比较容易，避免太分散容易漏掉。另外，还可以很方便地替换渲染环境，如渲染平台替换为 freeglut 时，需要将 GLFWwindow 替换为 void*，因为 freeglut 未提供类似 window 的数据结构。
​    application.h
  1. #pragma once
  3. #include "core_lib.h"
  5. #define app Application::getInstance()
  7. namespace glcore
  8. {
  9. /**
  10. * 应用程序, 存储全局的参数, 便于访问
  11. * @author little fat sheep
  12. */
  13. class Application {
  14. private:
  15.     static Application* sInstance;
  17. public:
  18.     int width = 0;
  19.     int height = 0;
  20.     float aspect = 1.0f;
  22. private:
  23.     GLFWwindow* m_window = nullptr;
  25. public:
  26.     static Application* getInstance();
  27.     ~Application();
  28.     void resize(int width, int height);
  29.     GLFWwindow* getWindow() { return m_window; }
  30.     void setWindow(GLFWwindow* window);
  31.     void releaseWindow();
  33. private:
  34.     Application() {};
  35. };
  36. } // 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.    
  19. }
  21. void Application::resize(int width, int height)
  22. {
  23.     this->width = width;
  24.     this->height = height;
  25.     this->aspect = (float) width / (float) height;
  26. }
  28. void Application::setWindow(GLFWwindow* window)
  29. {
  30.     m_window = window;
  31.     int width, height;
  32.     glfwGetFramebufferSize(window, &width, &height);
  33.     resize(width, height);
  34. }
  36. void Application::releaseWindow()
  37. {
  38.     if (m_window)
  39.     {
  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 <iostream>
  2. #include
  3. #include <string>
  5. #include "glcore/core_lib.h"
  6. #include "glcore/gl_inspector.h"
  8. // 以下内容为了不报错临时添加的 (glfw/freeglut已经创建了egl环境)
  9. #define EGL_SUCCESS             0x3000
  10. #define EGL_NOT_INITIALIZED     0x3001
  11. #define EGL_BAD_ACCESS          0x3002
  12. #define EGL_BAD_ALLOC           0x3003
  13. #define EGL_BAD_ATTRIBUTE       0x3004
  14. #define EGL_BAD_CONFIG          0x3005
  15. #define EGL_BAD_CONTEXT         0x3006
  16. #define EGL_BAD_SURFACE         0x3007
  17. #define EGL_BAD_DISPLAY         0x3008
  18. #define EGL_BAD_CURRENT_SURFACE 0x3009
  19. #define EGL_BAD_NATIVE_PIXMAP   0x300A
  20. #define EGL_BAD_NATIVE_WINDOW   0x300D
  21. #define EGL_BAD_PARAMETER       0x300C
  22. #define EGL_BAD_MATCH           0x3010
  23. #define EGL_CONTEXT_LOST        0x300E
  24. // 以上内容为了不报错临时添加的
  26. #define TAG "GLInspector"
  28. int eglGetError() { return 0; }
  30. using namespace std;
  32. namespace glcore
  33. {
  34. void GLInspector::checkEGLError(const char *tag)
  35. {
  36.     int error = eglGetError();
  37.     if (error != EGL_SUCCESS) {
  38.         printf("%s: %s failed: 0x%x\n", TAG, tag, error);
  39.     }
  40. }
  42. void GLInspector::checkEGLError()
  43. {
  44.     GLenum errorCode = eglGetError();
  45.     if (errorCode != EGL_SUCCESS) {
  46.         string error;
  47.         switch (errorCode)
  48.         {
  49.         case EGL_BAD_DISPLAY:
  50.             error = "EGL_BAD_DISPLAY";
  51.             break;
  52.         case EGL_NOT_INITIALIZED:
  53.             error = "EGL_NOT_INITIALIZED";
  54.             break;
  55.         case EGL_BAD_CONFIG:
  56.             error = "EGL_BAD_CONFIG";
  57.             break;
  58.         case EGL_BAD_CONTEXT:
  59.             error = "EGL_BAD_CONTEXT";
  60.             break;
  61.         case EGL_BAD_NATIVE_WINDOW:
  62.             error = "EGL_BAD_NATIVE_WINDOW";
  63.             break;
  64.         case EGL_BAD_SURFACE:
  65.             error = "EGL_BAD_SURFACE";
  66.             break;
  67.         case EGL_BAD_CURRENT_SURFACE:
  68.             error = "EGL_BAD_CURRENT_SURFACE";
  69.             break;
  70.         case EGL_BAD_ACCESS:
  71.             error = "EGL_BAD_ACCESS";
  72.             break;
  73.         case EGL_BAD_ALLOC:
  74.             error = "EGL_BAD_ALLOC";
  75.             break;
  76.         case EGL_BAD_ATTRIBUTE:
  77.             error = "EGL_BAD_ATTRIBUTE";
  78.             break;
  79.         case EGL_BAD_PARAMETER:
  80.             error = "EGL_BAD_PARAMETER";
  81.             break;
  82.         case EGL_BAD_NATIVE_PIXMAP:
  83.             error = "EGL_BAD_NATIVE_PIXMAP";
  84.             break;
  85.         case EGL_BAD_MATCH:
  86.             error = "EGL_BAD_MATCH";
  87.             break;
  88.         case EGL_CONTEXT_LOST:
  89.             error = "EGL_CONTEXT_LOST";
  90.             break;
  91.         default:
  92.             error = "UNKNOW";
  93.             break;
  94.         }
  95.         printf("checkEGLError failed: %s, 0x%x", error.c_str(), errorCode);
  96.         assert(false);
  97.     }
  98. }
  100. void GLInspector::printShaderInfoLog(GLuint shader, const char* tag)
  101. {
  102.     char infoLog[512];
  103.     glGetShaderInfoLog(shader, 512, nullptr, infoLog);
  104.     printf("%s: %s failed: %s\n", TAG, tag, infoLog);
  105. }
  107. void GLInspector::printProgramInfoLog(GLuint program, const char* tag)
  108. {
  109.     char infoLog[512];
  110.     glGetProgramInfoLog(program, 512, nullptr, infoLog);
  111.     printf("%s: %s failed: %s\n", TAG, tag, infoLog);
  112. }
  114. void GLInspector::checkGLError(const char *tag) {
  115.     GLenum error = glGetError();
  116.     if(error != GL_NO_ERROR) {
  117.         printf("%s: %s failed: 0x%x\n", TAG, tag, error);
  118.     }
  119. }
  121. void GLInspector::checkGLError()
  122. {
  123.     GLenum errorCode = glGetError();
  124.     if (errorCode != GL_NO_ERROR)
  125.     {
  126.         string error;
  127.         switch (errorCode)
  128.         {
  129.         case GL_INVALID_ENUM:
  130.             error = "GL_INVALID_ENUM";
  131.             break;
  132.         case GL_INVALID_VALUE:
  133.             error = "GL_INVALID_VALUE";
  134.             break;
  135.         case GL_INVALID_OPERATION:
  136.             error = "GL_INVALID_OPERATION";
  137.             break;
  138.         case GL_INVALID_INDEX:
  139.             error = "GL_INVALID_INDEX";
  140.             break;
  141.         case GL_INVALID_FRAMEBUFFER_OPERATION:
  142.             error = "GL_INVALID_FRAMEBUFFER_OPERATION";
  143.             break;
  144.         case GL_OUT_OF_MEMORY:
  145.             error = "GL_OUT_OF_MEMORY";
  146.             break;
  147.         default:
  148.             error = "UNKNOW";
  149.             break;
  150.         }
  151.         printf("checkError failed: %s, 0x%x\n", error.c_str(), errorCode);
  152.         assert(false);
  153.     }
  154. }
  155. } // namespace glcore
复制代码
2.6 EGLSurfaceView

​    EGLSurfaceView 主要承载了 EGL 环境搭建。EGL 详细介绍见 → 【OpenGL ES】EGL+FBO离屏渲染。
​    由于 GLFW 中已经创建了 EGL 环境，EGLSurfaceView 实际上是多余的，为了保持 glcore 在各个平台上的代码具有高度一致性，并且方便随时自主创建 EGL 环境，这里仍然保留了 EGLSurfaceView。本文中主要使用到 EGLSurfaceView 的内部类 Renderer，起到定制渲染流程规范的作用。
​    elg_surface_view.h
  1. #pragma once
  3. #include "core_lib.h"
  5. // 以下内容为了不报错临时添加的 (glfw/freeglut创建了egl环境)
  6. typedef void* EGLDisplay;
  7. typedef void* EGLConfig;
  8. typedef void* EGLContext;
  9. typedef void* EGLSurface;
  10. // 以上内容为了不报错临时添加的
  12. namespace glcore
  13. {
  14. /**
  15. * EGL环境封装类
  16. * glfw和freeglut中创建了egl环境, 因此该类可以去掉,
  17. * 但是为了方便将glcore迁移到需要用户搭建egl环境的平台中,
  18. * 暂时保留该类.
  19. *
  20. * @author little fat sheep
  21. */
  22. class EGLSurfaceView
  23. {
  24. public:
  25.     class Renderer;
  27. private:
  28.     Renderer* m_renderer = nullptr;
  29.     EGLDisplay m_eglDisplay;
  30.     EGLConfig m_eglConfig;
  31.     EGLContext m_eglContext;
  32.     EGLSurface m_eglSurface;
  33.     bool m_firstCreateSurface = true;
  35. public:
  36.     EGLSurfaceView();
  37.     ~EGLSurfaceView();
  38.     void setRenderer(Renderer* renderer);
  39.     bool surfaceCreated();
  40.     void surfaceChanged(int width, int height);
  41.     void drawFrame();
  42.     void surfaceDestroy();
  44. private:
  45.     void createDisplay();
  46.     void createConfig();
  47.     void createContext();
  48.     void createSurface();
  49.     void makeCurrent();
  51. public:
  52.     /**
  53.         * 渲染器接口, 类比GLSurfaceView.Renderer
  54.         * @author little fat sheep
  55.         */
  56.     class Renderer {
  57.     public:
  58.         virtual ~Renderer() {};
  59.         virtual void onSurfaceCreated() = 0;
  60.         virtual void onSurfaceChanged(int width, int height) = 0;
  61.         virtual void onDrawFrame() = 0;
  62.     };
  63. };
  64. } // namespace glcore
复制代码
​    elg_surface_view.cpp
  1. #include <iostream>
  3. #include "glcore/application.h"
  4. #include "glcore/elg_surface_view.h"
  5. #include "glcore/gl_inspector.h"
  7. #define TAG "EGLSurfaceView"
  9. // 以下内容为了不报错临时添加的 (glfw/freeglut已经创建了egl环境)
  10. #define EGL_RED_SIZE               0x3024
  11. #define EGL_GREEN_SIZE             0x3023
  12. #define EGL_BLUE_SIZE              0x3022
  13. #define EGL_ALPHA_SIZE             0x3021
  14. #define EGL_DEPTH_SIZE             0x3025
  15. #define EGL_RENDERABLE_TYPE        0x3040
  16. #define EGL_OPENGL_ES3_BIT         0x0040
  17. #define EGL_SURFACE_TYPE           0x3033
  18. #define EGL_WINDOW_BIT             0x0004
  19. #define EGL_NONE                   0x3038
  20. #define EGL_CONTEXT_CLIENT_VERSION 0x3098
  22. #define EGL_DEFAULT_DISPLAY ((EGLDisplay)0)
  23. #define EGL_NO_DISPLAY ((EGLDisplay)0)
  24. #define EGL_NO_CONTEXT ((EGLContext)0)
  25. #define EGL_NO_SURFACE ((EGLSurface)0)
  27. typedef int32_t EGLint;
  29. EGLDisplay eglGetDisplay(EGLDisplay a1) { return nullptr; }
  30. void eglInitialize(EGLDisplay a1, int* a3, int* a4) {}
  31. void eglChooseConfig(EGLDisplay a1, const EGLint* a2, EGLConfig* a3, EGLint a4, EGLint* a5) {}
  32. EGLContext eglCreateContext(EGLDisplay a1, EGLConfig a2, EGLContext a3, const EGLint* a4) { return nullptr; }
  33. EGLSurface eglCreateWindowSurface(EGLDisplay a1, EGLConfig a2, void* a3, const EGLint* a4) { return nullptr; }
  34. void eglMakeCurrent(EGLDisplay a1, EGLSurface a2, EGLSurface a3, EGLContext a4) {}
  35. void eglSwapBuffers(EGLDisplay a1, EGLSurface a2) {}
  36. void eglDestroySurface(EGLDisplay a1, EGLSurface a2) {}
  37. void eglDestroyContext(EGLDisplay a1, EGLContext a2) {}
  38. void eglTerminate(EGLDisplay a1) {}
  39. // 以上内容为了不报错临时添加的
  41. namespace glcore
  42. {
  43. EGLSurfaceView::EGLSurfaceView()
  44. {
  45.     printf("%s: init\n", TAG);
  46.     createDisplay();
  47.     createConfig();
  48.     createContext();
  49. }
  51. EGLSurfaceView::~EGLSurfaceView()
  52. {
  53.     printf("%s: destroy\n", TAG);
  54.     if (m_renderer)
  55.     {
  56.         delete m_renderer;
  57.         m_renderer = nullptr;
  58.     }
  59.     if (m_eglDisplay && m_eglDisplay != EGL_NO_DISPLAY)
  60.     {
  61.         // 与显示设备解绑
  62.         EGL_CALL(eglMakeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
  63.         // 销毁 EGLSurface
  64.         if (m_eglSurface && m_eglSurface != EGL_NO_SURFACE)
  65.         {
  66.             EGL_CALL(eglDestroySurface(m_eglDisplay, m_eglSurface));
  67.             delete &m_eglSurface;
  68.         }
  69.         // 销毁 EGLContext
  70.         if (m_eglContext && m_eglContext != EGL_NO_CONTEXT)
  71.         {
  72.             EGL_CALL(eglDestroyContext(m_eglDisplay, m_eglContext));
  73.             delete &m_eglContext;
  74.         }
  75.         // 销毁 EGLDisplay (显示设备)
  76.         EGL_CALL(eglTerminate(m_eglDisplay));
  77.         delete &m_eglDisplay;
  78.     }
  79.     app->releaseWindow();
  80.     delete app;
  81. }
  83. void EGLSurfaceView::setRenderer(Renderer *renderer)
  84. {
  85.     printf("%s: setRenderer\n", TAG);
  86.     m_renderer = renderer;
  87. }
  89. bool EGLSurfaceView::surfaceCreated()
  90. {
  91.     printf("%s: surfaceCreated\n", TAG);
  92.     app->resize(app->width, app->height);
  93.     createSurface();
  94.     makeCurrent();
  95.     if (m_renderer && m_firstCreateSurface)
  96.     {
  97.         m_renderer->onSurfaceCreated();
  98.         m_firstCreateSurface = false;
  99.     }
  100.     return true;
  101. }
  103. void EGLSurfaceView::surfaceChanged(int width, int height)
  104. {
  105.     printf("%s: surfaceChanged, width: %d, height: %d\n", TAG, width, height);
  106.     app->resize(width, height);
  107.     if (m_renderer)
  108.     {
  109.         m_renderer->onSurfaceChanged(width, height);
  110.     }
  111. }
  113. void EGLSurfaceView::drawFrame()
  114. {
  115.     if (!m_eglSurface || m_eglSurface == EGL_NO_SURFACE || !m_renderer)
  116.     {
  117.         return;
  118.     }
  119.     m_renderer->onDrawFrame();
  120.     EGL_CALL(eglSwapBuffers(m_eglDisplay, m_eglSurface));
  121. }
  123. void EGLSurfaceView::surfaceDestroy()
  124. {
  125.     printf("%s: surfaceDestroy\n", TAG);
  126.     if (m_eglDisplay && m_eglDisplay != EGL_NO_DISPLAY)
  127.     {
  128.         // 与显示设备解绑
  129.         EGL_CALL(eglMakeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
  130.         // 销毁 EGLSurface
  131.         if (m_eglSurface && m_eglSurface != EGL_NO_SURFACE)
  132.         {
  133.             EGL_CALL(eglDestroySurface(m_eglDisplay, m_eglSurface));
  134.             m_eglSurface = nullptr;
  135.         }
  136.     }
  137.     app->releaseWindow();
  138. }
  140. // 1.创建EGLDisplay
  141. void EGLSurfaceView::createDisplay()
  142. {
  143.     EGL_CALL(m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY));
  144.     EGL_CALL(eglInitialize(m_eglDisplay, nullptr, nullptr));
  145. }
  147. // 2.创建EGLConfig
  148. void EGLSurfaceView::createConfig()
  149. {
  150.     if (m_eglDisplay && m_eglDisplay != EGL_NO_DISPLAY)
  151.     {
  152.         const EGLint configAttrs[] = {
  153.                 EGL_RED_SIZE, 8,
  154.                 EGL_GREEN_SIZE, 8,
  155.                 EGL_BLUE_SIZE, 8,
  156.                 EGL_ALPHA_SIZE, 8,
  157.                 EGL_DEPTH_SIZE, 8,
  158.                 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES3_BIT,
  159.                 EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
  160.                 EGL_NONE
  161.         };
  162.         EGLint numConfigs;
  163.         EGL_CALL(eglChooseConfig(m_eglDisplay, configAttrs, &m_eglConfig, 1, &numConfigs));
  164.     }
  165. }
  167. // 3.创建EGLContext
  168. void EGLSurfaceView::createContext()
  169. {
  170.     if (m_eglConfig)
  171.     {
  172.         const EGLint contextAttrs[] = {
  173.                 EGL_CONTEXT_CLIENT_VERSION, 3,
  174.                 EGL_NONE
  175.         };
  176.         EGL_CALL(m_eglContext = eglCreateContext(m_eglDisplay, m_eglConfig, EGL_NO_CONTEXT, contextAttrs));
  177.     }
  178. }
  180. // 4.创建EGLSurface
  181. void EGLSurfaceView::createSurface()
  182. {
  183.     if (m_eglContext && m_eglContext != EGL_NO_CONTEXT) {
  184.         EGL_CALL(m_eglSurface = eglCreateWindowSurface(m_eglDisplay, m_eglConfig, app->getWindow(), nullptr));
  185.     }
  186. }
  188. // 5.绑定EGLSurface和EGLContext到显示设备（EGLDisplay）
  189. void EGLSurfaceView::makeCurrent()
  190. {
  191.     if (m_eglSurface && m_eglSurface != EGL_NO_SURFACE)
  192.     {
  193.         EGL_CALL(eglMakeCurrent(m_eglDisplay, m_eglSurface, m_eglSurface, m_eglContext));
  194.     }
  195. }
  196. } // 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 <iostream>
  3. #include "glcore/gl_inspector.h"
  4. #include "glcore/shader_program.h"
  6. #define TAG "ShaderProgram"
  8. namespace glcore
  9. {
  10. ShaderProgram::ShaderProgram(const char* vertexCode, const char* fragmentCode)
  11. {
  12.     compileShaders(vertexCode, fragmentCode);
  13. }
  15. ShaderProgram::~ShaderProgram()
  16. {
  17.     if (m_program)
  18.     {
  19.         GL_CALL(glUseProgram(0));
  20.         GL_CALL(glDeleteProgram(m_program));
  21.         m_program = 0;
  22.     }
  23.     m_attributes.clear();
  24.     m_uniforms.clear();
  25. }
  27. void ShaderProgram::bind()
  28. {
  29.     GL_CALL(glUseProgram(m_program));
  30. }
  32. void ShaderProgram::enableVertexAttribArray(const char* name)
  33. {
  34.     int location = fetchAttributeLocation(name);
  35.     enableVertexAttribArray(location);
  36. }
  38. void ShaderProgram::enableVertexAttribArray(int location)
  39. {
  40.     GL_CALL(glEnableVertexAttribArray(location));
  41. }
  43. void ShaderProgram::setVertexAttribPointer(const char *name, int size, int type, bool normalize, int stride, int offset)
  44. {
  45.     int location = fetchAttributeLocation(name);
  46.     setVertexAttribPointer(location, size, type, normalize, stride, offset);
  47. }
  49. void ShaderProgram::setVertexAttribPointer(int location, int size, int type, bool normalize, int stride, int offset)
  50. {
  51.     GL_CALL(glVertexAttribPointer(location, size, type, normalize, stride, (void*) offset));
  52. }
  54. void ShaderProgram::disableVertexAttribArray(const char* name)
  55. {
  56.     int location = fetchAttributeLocation(name);
  57.     disableVertexAttribArray(location);
  58. }
  60. void ShaderProgram::disableVertexAttribArray(int location)
  61. {
  62.     GL_CALL(glDisableVertexAttribArray(location));
  63. }
  65. void ShaderProgram::setUniformi(const char* name, int value)
  66. {
  67.     int location = fetchUniformLocation(name);
  68.     GL_CALL(glUniform1i(location, value));
  69. }
  71. void ShaderProgram::setUniformi(int location, int value)
  72. {
  73.     GL_CALL(glUniform1i(location, value));
  74. }
  76. void ShaderProgram::setUniformi(const char* name, int value1, int value2)
  77. {
  78.     int location = fetchUniformLocation(name);
  79.     GL_CALL(glUniform2i(location, value1, value2));
  80. }
  82. void ShaderProgram::setUniformi(int location, int value1, int value2)
  83. {
  84.     GL_CALL(glUniform2i(location, value1, value2));
  85. }
  87. void ShaderProgram::setUniformi(const char* name, int value1, int value2, int value3)
  88. {
  89.     int location = fetchUniformLocation(name);
  90.     GL_CALL(glUniform3i(location, value1, value2, value3));
  91. }
  93. void ShaderProgram::setUniformi(int location, int value1, int value2, int value3)
  94. {
  95.     GL_CALL(glUniform3i(location, value1, value2, value3));
  96. }
  98. void ShaderProgram::setUniformi(const char* name, int value1, int value2, int value3, int value4)
  99. {
  100.     int location = fetchUniformLocation(name);
  101.     GL_CALL(glUniform4i(location, value1, value2, value3, value4));
  102. }
  104. void ShaderProgram::setUniformi(int location, int value1, int value2, int value3, int value4)
  105. {
  106.     GL_CALL(glUniform4i(location, value1, value2, value3, value4));
  107. }
  109. void ShaderProgram::setUniformf(const char* name, float value)
  110. {
  111.     int location = fetchUniformLocation(name);
  112.     GL_CALL(glUniform1f(location, value));
  113. }
  115. void ShaderProgram::setUniformf(int location, float value)
  116. {
  117.     GL_CALL(glUniform1f(location, value));
  118. }
  120. void ShaderProgram::setUniformf(const char* name, float value1, float value2)
  121. {
  122.     int location = fetchUniformLocation(name);
  123.     GL_CALL(glUniform2f(location, value1, value2));
  124. }
  126. void ShaderProgram::setUniformf(int location, float value1, float value2)
  127. {
  128.     GL_CALL(glUniform2f(location, value1, value2));
  129. }
  131. void ShaderProgram::setUniformf(const char* name, float value1, float value2, int value3)
  132. {
  133.     int location = fetchUniformLocation(name);
  134.     GL_CALL(glUniform3f(location, value1, value2, value3));
  135. }
  137. void ShaderProgram::setUniformf(int location, float value1, float value2, int value3)
  138. {
  139.     GL_CALL(glUniform3f(location, value1, value2, value3));
  140. }
  142. void ShaderProgram::setUniformf(const char* name, float value1, float value2, int value3, int value4)
  143. {
  144.     int location = fetchUniformLocation(name);
  145.     GL_CALL(glUniform4f(location, value1, value2, value3, value4));
  146. }
  148. void ShaderProgram::setUniformf(int location, float value1, float value2, int value3, int value4)
  149. {
  150.     GL_CALL(glUniform4f(location, value1, value2, value3, value4));
  151. }
  153. void ShaderProgram::setUniform1fv(const char* name, int count, const float values[])
  154. {
  155.     int location = fetchUniformLocation(name);
  156.     GL_CALL(glUniform1fv(location, count, values));
  157. }
  159. void ShaderProgram::setUniform1fv(int location, int count, const float values[])
  160. {
  161.     GL_CALL(glUniform1fv(location, count, values));
  162. }
  164. void ShaderProgram::setUniform2fv(const char* name, int count, const float values[])
  165. {
  166.     int location = fetchUniformLocation(name);
  167.     GL_CALL(glUniform2fv(location, count / 2, values));
  168. }
  170. void ShaderProgram::setUniform2fv(int location, int count, const float values[])
  171. {
  172.     GL_CALL(glUniform2fv(location, count / 2, values));
  173. }
  175. void ShaderProgram::setUniform3fv(const char* name, int count, const float values[])
  176. {
  177.     int location = fetchUniformLocation(name);
  178.     GL_CALL(glUniform3fv(location, count / 3, values));
  179. }
  181. void ShaderProgram::setUniform3fv(int location, int count, const float values[])
  182. {
  183.     GL_CALL(glUniform3fv(location, count / 3, values));
  184. }
  186. void ShaderProgram::setUniform4fv(const char* name, int count, const float values[])
  187. {
  188.     int location = fetchUniformLocation(name);
  189.     GL_CALL(glUniform4fv(location, count / 4, values));
  190. }
  192. void ShaderProgram::setUniform4fv(int location, int count, const float values[])
  193. {
  194.     GL_CALL(glUniform4fv(location, count / 4, values));
  195. }
  197. void ShaderProgram::setUniformMatrix2fv(const char* name, int count, bool transpose, const float *value)
  198. {
  199.     int location = fetchUniformLocation(name);
  200.     GL_CALL(glUniformMatrix2fv(location, count, transpose, value));
  201. }
  203. void ShaderProgram::setUniformMatrix2fv(int location, int count, bool transpose, const float *value)
  204. {
  205.     GL_CALL(glUniformMatrix2fv(location, count, transpose, value));
  206. }
  208. void ShaderProgram::setUniformMatrix3fv(const char* name, int count, bool transpose, const float *value)
  209. {
  210.     int location = fetchUniformLocation(name);
  211.     GL_CALL(glUniformMatrix3fv(location, count, transpose, value));
  212. }
  214. void ShaderProgram::setUniformMatrix3fv(int location, int count, bool transpose, const float *value)
  215. {
  216.     GL_CALL(glUniformMatrix3fv(location, count, transpose, value));
  217. }
  219. void ShaderProgram::setUniformMatrix4fv(const char* name, int count, bool transpose, const float *value)
  220. {
  221.     int location = fetchUniformLocation(name);
  222.     GL_CALL(glUniformMatrix4fv(location, count, transpose, value));
  223. }
  225. void ShaderProgram::setUniformMatrix4fv(int location, int count, bool transpose, const float *value)
  226. {
  227.     GL_CALL(glUniformMatrix4fv(location, count, transpose, value));
  228. }
  230. int ShaderProgram::fetchAttributeLocation(const char* name)
  231. {
  232.     int location;
  233.     auto it = m_attributes.find(name);
  234.     if (it == m_attributes.end())
  235.     {
  236.         GL_CALL(location = glGetAttribLocation(m_program, name));
  237.         if (location == -1) {
  238.             printf("%s: no attribute: %s\n", TAG, name);
  239.             //GLInspector::printProgramInfoLog(m_program, "fetchAttributeLocation");
  240.             return -1;
  241.         }
  242.         m_attributes[name] = location;
  243.     }
  244.     else
  245.     {
  246.         location = it->second;
  247.     }
  248.     return location;
  249. }
  251. int ShaderProgram::fetchUniformLocation(const char* name)
  252. {
  253.     int location;
  254.     auto it = m_uniforms.find(name);
  255.     if (it == m_uniforms.end())
  256.     {
  257.         GL_CALL(location = glGetUniformLocation(m_program, name));
  258.         if (location == -1) {
  259.             printf("%s: no uniform: %s\n", TAG, name);
  260.             //GLInspector::printProgramInfoLog(m_program, "fetchUniformLocation");
  261.             return -1;
  262.         }
  263.         m_uniforms[name] = location;
  264.     }
  265.     else
  266.     {
  267.         location = it->second;
  268.     }
  269.     return location;
  270. }
  272. void ShaderProgram::compileShaders(const char* vertexCode, const char* fragmentCode)
  273. {
  274.     GLuint vertexShader = loadShader(GL_VERTEX_SHADER, vertexCode);
  275.     GLuint fragmentShader = loadShader(GL_FRAGMENT_SHADER, fragmentCode);
  276.     m_program = linkProgram(vertexShader, fragmentShader);
  277. }
  279. GLuint ShaderProgram::loadShader(GLenum type, const char* source)
  280. {
  281.     GL_CALL(GLuint shader = glCreateShader(type));
  282.     GL_CALL(glShaderSource(shader, 1, &source, nullptr));
  283.     GL_CALL(glCompileShader(shader));
  284.     GLint success;
  285.     glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
  286.     if (!success) {
  287.         GLInspector::printShaderInfoLog(shader, "loadShader");
  288.         return 0;
  289.     }
  290.     return shader;
  291. }
  293. GLuint ShaderProgram::linkProgram(GLuint vertexShader, GLuint fragmentShader)
  294. {
  295.     GL_CALL(GLuint program = glCreateProgram());
  296.     GL_CALL(glAttachShader(program, vertexShader));
  297.     GL_CALL(glAttachShader(program, fragmentShader));
  298.     GL_CALL(glLinkProgram(program));
  299.     GLint success;
  300.     glGetProgramiv(program, GL_LINK_STATUS, &success);
  301.     if (!success) {
  302.         GLInspector::printProgramInfoLog(m_program, "linkProgram");
  303.     }
  304.     GL_CALL(glDeleteShader(vertexShader));
  305.     GL_CALL(glDeleteShader(fragmentShader));
  306.     return program;
  307. }
  308. } // 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 <iostream>
  3. #include "glcore/gl_inspector.h"
  4. #include "glcore/vertex_buffer_object.h"
  6. #define TAG "VertexBufferObject"
  8. namespace glcore
  9. {
  10. VertexBufferObject::VertexBufferObject(bool isStatic, initializer_list<VertexAttribute*> attributes):
  11.     VertexBufferObject(isStatic, new VertexAttributes(attributes))
  12. {
  13. }
  15. VertexBufferObject::VertexBufferObject(bool isStatic, VertexAttributes* attributes):
  16.     m_attributes(attributes)
  17. {
  18.     m_usage = isStatic ? GL_STATIC_DRAW : GL_DYNAMIC_DRAW;
  19.     GL_CALL(glGenBuffers(1, &m_vboHandle));
  20.     printf("%s: init: %d\n", TAG, m_vboHandle);
  21. }
  23. VertexBufferObject::~VertexBufferObject()
  24. {
  25.     printf("%s: destroy\n", TAG);
  26.     GL_CALL(glBindBuffer(GL_ARRAY_BUFFER, 0));
  27.     GL_CALL(glDeleteBuffers(1, &m_vboHandle));
  28.     m_vboHandle = 0;
  29.     delete m_attributes;
  30.     delete[] m_vertices;
  31. }
  33. void VertexBufferObject::setVertices(float* vertices, int bytes)
  34. {
  35.     m_vertices = vertices;
  36.     m_vertexNum = bytes / m_attributes->vertexSize;
  37.     m_bytes = bytes;
  38.     m_isDirty = true;
  39.     if (m_isBound)
  40.     {
  41.         applyBufferData();
  42.     }
  43. }
  45. void VertexBufferObject::bind(ShaderProgram* shader)
  46. {
  47.     bind(shader, nullptr);
  48. }
  50. void VertexBufferObject::bind(ShaderProgram* shader, int* locations)
  51. {
  52.     GL_CALL(glBindBuffer(GL_ARRAY_BUFFER, m_vboHandle));
  53.     if (m_isDirty)
  54.     {
  55.         applyBufferData();
  56.     }
  57.     if (locations == nullptr)
  58.     {
  59.         for (int i = 0; i < m_attributes->size(); i++)
  60.         {
  61.             VertexAttribute* attribute = m_attributes->get(i);
  62.             shader->enableVertexAttribArray(attribute->alias);
  63.             shader->setVertexAttribPointer(attribute->alias, attribute->numComponents,
  64.                attribute->type, attribute->normalized, m_attributes->vertexSize,
  65.                attribute->offset);
  66.         }
  67.     }
  68.     else
  69.     {
  70.         for (int i = 0; i < m_attributes->size(); i++)
  71.         {
  72.             VertexAttribute* attribute = m_attributes->get(i);
  73.             shader->enableVertexAttribArray(locations[i]);
  74.             shader->setVertexAttribPointer(locations[i], attribute->numComponents,
  75.                attribute->type, attribute->normalized, m_attributes->vertexSize,
  76.                attribute->offset);
  77.         }
  78.     }
  79.     m_isBound = true;
  80. }
  82. void VertexBufferObject::unbind(ShaderProgram* shader)
  83. {
  84.     unbind(shader, nullptr);
  85. }
  87. void VertexBufferObject::unbind(ShaderProgram* shader, int* locations)
  88. {
  89.     if (locations == nullptr)
  90.     {
  91.         for (int i = 0; i < m_attributes->size(); i++)
  92.         {
  93.             shader->disableVertexAttribArray(m_attributes->get(i)->alias);
  94.         }
  95.     }
  96.     else
  97.     {
  98.         for (int i = 0; i < m_attributes->size(); i++)
  99.         {
  100.             shader->disableVertexAttribArray(locations[i]);
  101.         }
  102.     }
  103.     m_isBound = false;
  104. }
  106. void VertexBufferObject::applyBufferData()
  107. {
  108.     GL_CALL(glBufferData(GL_ARRAY_BUFFER, m_bytes, m_vertices, m_usage));
  109.     m_isDirty = false;
  110. }
  111. } // 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 <iostream>
  2. #include <string>
  4. #include "glcore/core_lib.h"
  5. #include "glcore/shader_program.h"
  6. #include "glcore/vertex_attribute.h"
  7. #include "glcore/vertex_attributes.h"
  9. #define TAG "VertexAttribute"
  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.     printf("%s: create, alias: %s\n", TAG, 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 <iostream>
  3. #include "glcore/gl_inspector.h"
  4. #include "glcore/vertex_buffer_object_with_vao.h"
  6. #define TAG "VertexBufferObjectWithVAO"
  8. namespace glcore
  9. {
  10. VertexBufferObjectWithVAO::VertexBufferObjectWithVAO(bool isStatic,
  11.     initializer_list<VertexAttribute*> attributes):
  12.         VertexBufferObjectWithVAO(isStatic, new VertexAttributes(attributes))
  13. {
  14. }
  16. VertexBufferObjectWithVAO::VertexBufferObjectWithVAO(bool isStatic, VertexAttributes* attributes):
  17.     VertexBufferObject(isStatic, attributes)
  18. {
  19.     GL_CALL(glGenVertexArrays(1, &m_vaoHandle));
  20.     printf("%s: init: %d\n", TAG, m_vaoHandle);
  21. }
  23. VertexBufferObjectWithVAO::~VertexBufferObjectWithVAO()
  24. {
  25.     printf("%s: destroy\n", TAG);
  26.     GL_CALL(glDeleteVertexArrays(1, &m_vaoHandle));
  27. }
  29. void VertexBufferObjectWithVAO::bind(ShaderProgram* shader, int* locations)
  30. {
  31.     GL_CALL(glBindVertexArray(m_vaoHandle));
  32.     if (m_isDirty)
  33.     {
  34.         VertexBufferObject::bind(shader, locations);
  35.     }
  36.     m_isBound = true;
  37. }
  39. void VertexBufferObjectWithVAO::unbind(ShaderProgram* shader, int* locations)
  40. {
  41.     GL_CALL(glBindVertexArray(0));
  42.     m_isBound = false;
  43. }
  44. } // 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 <iostream>
  3. #include "glcore/gl_inspector.h"
  4. #include "glcore/index_buffer_object.h"
  6. #define TAG "IndexBufferObject"
  8. namespace glcore
  9. {
  10. IndexBufferObject::IndexBufferObject(bool isStatic):
  11.         IndexBufferObject(isStatic, GL_UNSIGNED_SHORT)
  12. {
  13. }
  15. IndexBufferObject::IndexBufferObject(bool isStatic, GLenum type)
  16. {
  17.     m_usage = isStatic ? GL_STATIC_DRAW : GL_DYNAMIC_DRAW;
  18.     m_type = type;
  19.     GL_CALL(glGenBuffers(1, &m_iboHandle));
  20.     printf("%s: init: %d\n", TAG, m_iboHandle);
  21. }
  23. IndexBufferObject::~IndexBufferObject()
  24. {
  25.     printf("%s: destroy\n", TAG);
  26.     GL_CALL(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0));
  27.     GL_CALL(glDeleteBuffers(1, &m_iboHandle));
  28.     m_iboHandle = 0;
  29.     delete[] m_indices;
  30. }
  32. void IndexBufferObject::setIndices(void* indices, int bytes)
  33. {
  34.     setIndices(indices, bytes, m_type);
  35. }
  37. void IndexBufferObject::setIndices(void* indices, int bytes, GLenum type)
  38. {
  39.     m_indices = indices;
  40.     m_type = type;
  41.     m_indexNum = bytes > 0 ? bytes / getTypeSize() : 0;
  42.     m_bytes = bytes;
  43.     m_isDirty = true;
  44.     if (m_isBound)
  45.     {
  46.         applyBufferData();
  47.     }
  48. }
  50. void IndexBufferObject::bind()
  51. {
  52.     GL_CALL(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_iboHandle));
  53.     if (m_isDirty)
  54.     {
  55.         applyBufferData();
  56.     }
  57.     m_isBound = true;
  58. }
  60. void IndexBufferObject::unbind()
  61. {
  62.     GL_CALL(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0));
  63.     m_isBound = false;
  64. }
  66. void IndexBufferObject::applyBufferData()
  67. {
  68.     GL_CALL(glBufferData(GL_ELEMENT_ARRAY_BUFFER, m_bytes, m_indices, m_usage));
  69.     //GLInspector::checkGLError("ibo: glBufferData");
  70.     m_isDirty = false;
  71. }
  73. int IndexBufferObject::getTypeSize() {
  74.     switch (m_type) {
  75.         case GL_UNSIGNED_SHORT:
  76.             return 2;
  77.         case GL_UNSIGNED_INT:
  78.             return 4;
  79.     }
  80.     return 2;
  81. }
  82. } // 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; // 顶点索引缓冲对象
  26. public:
  27.     Mesh(bool isStatic, initializer_list<VertexAttribute*> attributes);
  28.     Mesh(bool isStatic, VertexAttributes* attributes);
  29.     Mesh(bool useVao, bool isStatic, initializer_list<VertexAttribute*> attributes);
  30.     Mesh(bool useVao, bool isStatic, VertexAttributes* attributes);
  31.     ~Mesh();
  32.     void setVertices(float* vertices, int bytes); // 设置顶点属性
  33.     void setIndices(void* indices, int bytes); // 设置顶点索引
  34.     void setIndices(void* indices, int bytes, GLenum type); // 设置顶点索引
  35.     void render(ShaderProgram* shader, GLenum primitiveType); // 渲染
  36. };
  37. } // 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::render(ShaderProgram* shader, GLenum primitiveType)
  51. {
  52.     m_vbo->bind(shader);
  53.     if (m_ibo->getNumIndices() > 0) {
  54.         m_ibo->bind();
  55.         GL_CALL(glDrawElements(primitiveType, m_ibo->getNumIndices(), m_ibo->getType(), nullptr));
  56.         m_ibo->unbind();
  57.     } else {
  58.         GL_CALL(glDrawArrays(primitiveType, 0, m_vbo->getNumVertices()));
  59.     }
  60.     m_vbo->unbind(shader);
  61. }
  62. } // 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[6] { 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[20] { // 中间渲染(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[20] { // 终端渲染使用
  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"
  5. #include "shader_program.h"
  6. #include "texture_action.h"
  8. namespace glcore
  9. {
  10. /**
  11. * 纹理贴图
  12. * @author little fat sheep
  13. */
  14. class GLTexture: public TextureAction
  15. {
  16. private:
  17.     GLuint m_textureHandle = 0; // 纹理句柄
  18.     int m_width = 0; // 纹理宽度
  19.     int m_height = 0; // 纹理高度
  20.     GLint m_filter = GL_LINEAR; // 滤波方式
  21.     GLint m_wrap = GL_CLAMP_TO_EDGE; // 环绕方式
  22.     const char* m_alias = ShaderProgram::UNIFORM_TEXTURE; // 纹理别名(着色器中变量名)
  23.     GLenum m_unit = 0; // 纹理单元 (可能有多个纹理)
  24.     bool m_isDirty = false; // 是否有脏数据 (纹理参数需要更新)
  26. public:
  27.     GLTexture(int width, int height);
  28.     GLTexture(void *buffer, int width, int height);
  29.     ~GLTexture() override;
  30.     void setTexture(const void *buffer);
  31.     void setTexParameter(GLint filter, GLint wrap) override;
  32.     void setBindParameter(char* alias, GLenum unit) override;
  33.     void bind(ShaderProgram* shader) override;
  34.     int getWidth() { return m_width; }
  35.     int getHeight() { return m_height; }
  37. private:
  38.     void applyTexParameter();
  39. };
  40. } // 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. * void* buffer = stbi_load(filePath, &width, &height, &channels, STBI_rgb_alpha)
  29. */
  30. void GLTexture::setTexture(const void *buffer)
  31. {
  32.     GL_CALL(glGenTextures(1, &m_textureHandle));
  33.     GL_CALL(glBindTexture(GL_TEXTURE_2D, m_textureHandle));
  34.     applyTexParameter();
  35.     GL_CALL(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_width, m_height, 0,
  36.                  GL_RGBA, GL_UNSIGNED_BYTE, buffer));
  37.     GL_CALL(glGenerateMipmap(GL_TEXTURE_2D));
  38.     GL_CALL(glBindTexture(GL_TEXTURE_2D, 0));
  39.     //GLInspector::checkGLError("setTexture");
  40. }
  42. void GLTexture::setTexParameter(GLint filter, GLint wrap)
  43. {
  44.     m_filter = filter;
  45.     m_wrap = wrap;
  46.     m_isDirty = true;
  47. }
  49. void GLTexture::setBindParameter(char *alias, GLenum unit)
  50. {
  51.     m_alias = alias;
  52.     m_unit = unit;
  53. }
  55. void GLTexture::bind(ShaderProgram *shader)
  56. {
  57.     shader->setUniformi(m_alias, m_unit);
  58.     GL_CALL(glActiveTexture(GL_TEXTURE0 + m_unit));
  59.     GL_CALL(glBindTexture(GL_TEXTURE_2D, m_textureHandle));
  60.     if (m_isDirty)
  61.     {
  62.         applyTexParameter();
  63.     }
  64. }
  66. void GLTexture::applyTexParameter()
  67. {
  68.     GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, m_filter));
  69.     GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, m_filter));
  70.     GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, m_wrap));
  71.     GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, m_wrap));
  72.     m_isDirty = false;
  73. }
  74. } // namespace glcore
复制代码
2.13 FBO

​    FBO 是 Frame Buffer Object 的简称，即帧缓冲对象，主要用于离屏渲染、特效叠加，
​    frame_buffer_object.h
  1. #pragma once
  3. #include "core_lib.h"
  5. #include "shader_program.h"
  6. #include "texture_action.h"
  7. #include "format.h"
  9. namespace glcore
  10. {
  11. /**
  12. * 帧缓冲对象 (简称FBO, 用于离屏渲染)
  13. * @author little fat sheep
  14. */
  15. class FrameBufferObject: public TextureAction
  16. {
  17. private:
  18.     Format* m_format; // 颜色格式
  19.     int m_width; // 缓冲区宽度
  20.     int m_height; // 缓冲区高度
  21.     bool m_hasDepth; // 是否有深度缓冲区
  22.     bool m_hasStencil; // 是否有模板缓冲区
  23.     GLuint m_frameBufferHandle; // 帧缓冲区句柄
  24.     GLuint m_depthBufferHandle; // 深度缓冲区句柄
  25.     GLuint m_stencilBufferHandle; // 模板缓冲区句柄
  26.     GLuint m_colorTextureHandle; // 颜色缓冲区句柄
  27.     GLint m_preFramebufferHandle; // 前一个帧缓冲区句柄
  28.     int m_preFramebufferViewPort[4]; // 前一个帧缓冲区视口
  29.     GLint m_filter = GL_LINEAR; // 滤波方式
  30.     GLint m_wrap = GL_CLAMP_TO_EDGE; // 环绕方式
  31.     const char* m_alias = ShaderProgram::UNIFORM_TEXTURE; // 纹理别名(着色器中变量名)
  32.     GLenum m_unit = 0; // 纹理单元 (可能有多个纹理)
  33.     bool m_isDirty = true; // 是否有脏数据 (纹理参数需要更新)
  35. public:
  36.     FrameBufferObject(Format* format, int width, int height, bool hasDepth, bool hasStencil);
  37.     ~FrameBufferObject() override;
  38.     void setTexParameter(GLint filter, GLint wrap) override;
  39.     void setBindParameter(char* alias, GLenum unit) override;
  40.     void begin(); // 开始将内容渲染到fbo
  41.     void end(); // 结束将内容渲染到fbo
  42.     void bind(ShaderProgram* shader) override;
  44. private:
  45.     void applyTexParameter();
  46. };
  47. } // 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::RGB565()
  17. {
  18.     return new Format(GL_RGB, GL_UNSIGNED_SHORT_5_6_5);
  19. }
  21. Format *Format::RGBA4444()
  22. {
  23.     return new Format(GL_RGB, GL_UNSIGNED_SHORT_4_4_4_4);
  24. }
  26. Format *Format::RGB888()
  27. {
  28.     return new Format(GL_RGB, GL_UNSIGNED_BYTE);
  29. }
  31. Format *Format::RGBA8888()
  32. {
  33.     return new Format(GL_RGBA, GL_UNSIGNED_BYTE);
  34. }
  35. } // namespace glcore
复制代码
3 工具相关

​    本节主要介绍 glcore 框架在初始化过程中所依附的工具类，如字符串加载工具、图片加载工具等，它们与平台相关（如 Android 平台字符串和图片加载依赖 JNI），不便于进行跨平台迁移，因此不能将它们归入 glcore 框架中。
3.1 StringUtils

​    StringUtils 用于加载顶点和片元着色器资源为字符串。
​    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 filePath 资源文件路径, 如: "assets/shaders/vertex_shader.glsl"
  13.      */
  14.     static const char* loadStringFromFile(const char* filePath);
  15. };
复制代码
​    string_utils.cpp
  1. #include <fstream>
  2. #include <sstream>
  3. #include <string>
  5. #include "utils/string_utils.h"
  7. using namespace std;
  9. const char* StringUtils::loadStringFromFile(const char* filePath)
  10. {
  11.     ifstream file(filePath);
  12.     if (!file.is_open())
  13.     {
  14.                 printf("failed to open file: %s\n", filePath);
  15.                 return nullptr;
  16.     }
  17.     stringstream buffer;
  18.     buffer << file.rdbuf();
  19.     file.close();
  20.     string content = buffer.str();
  21.     // 复制字符串, 避免content被回收导致悬垂指针问题
  22.     char * res = strdup(content.c_str());
  23.     return res;
  24. }
复制代码
4 应用

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

​    my_renderer.h
  1. #pragma once
  3. struct BitmapData
  4. {
  5.     void* buffer;
  6.     int width;
  7.     int height;
  8. };
  10. /**
  11. * Bitmap工具类
  12. * @author little fat sheep
  13. */
  14. class BitmapUtils
  15. {
  16. public:
  17.     /**
  18.     * 根据资源文件路径读取bitmap
  19.     * @param filePath 资源路径, 如: "assets/textures/xxx.jpg"
  20.     */
  21.     static BitmapData* loadBitmapDataFromFile(const char* filePath);
  22. };
复制代码
​    my_renderer.cpp
  1. #define STB_IMAGE_IMPLEMENTATION
  2. #include "stb/stb_image.h"
  4. #include "utils/bitmap_utils.h"
  6. BitmapData* BitmapUtils::loadBitmapDataFromFile(const char* filePath) {
  7.     int width, height, channels;
  8.         unsigned char* data = stbi_load(filePath, &width, &height, &channels, STBI_rgb_alpha);
  9.         BitmapData* bitmapData = new BitmapData();
  10.         bitmapData->buffer = data;
  11.         bitmapData->width = width;
  12.         bitmapData->height = height;
  13.         return bitmapData;
  14. }
复制代码
4.2 DispersionEffect

​    DispersionEffect 是色散特效。
​    dispersion_effect.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. };
复制代码
​    dispersion_effect.cpp
  1. #include <chrono>
  2. #include <iostream>
  4. #include "glcore/core.h"
  5. #include "render/my_renderer.h"
  7. #define TAG "MyRenderer"
  9. using namespace glcore;
  10. using namespace std::chrono;
  12. MyRenderer::MyRenderer()
  13. {
  14.     printf("%s: init\n", TAG);
  15.     m_dispersionEffect = new DispersionEffect();
  16.     m_jellyEffect = new JellyEffect();
  17.     m_jellyEffect->setTexAction(m_dispersionEffect);
  18. }
  20. MyRenderer::~MyRenderer()
  21. {
  22.     printf("%s: destroy\n", TAG);
  23.     delete m_dispersionEffect;
  24.     delete m_jellyEffect;
  25. }
  27. void MyRenderer::onSurfaceCreated()
  28. {
  29.     printf("%s: onSurfaceCreated\n", TAG);
  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.     printf("%s: onSurfaceChanged, width: %d, height: %d\n", TAG, width, height);
  39.     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. }
复制代码
​    dispersion_vert.glsl
  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_frag.glsl
  1. #include <iostream>
  3. #include "glcore/core.h"
  5. #include "render/dispersion_effect.h"
  6. #include "utils/bitmap_utils.h"
  7. #include "utils/string_utils.h"
  9. #define TAG "DispersionEffect"
  11. using namespace glcore;
  13. DispersionEffect::DispersionEffect()
  14. {
  15.     printf("%s: init\n", TAG);
  16. }
  18. DispersionEffect::~DispersionEffect()
  19. {
  20.     printf("%s: destroy\n", TAG);
  21.     delete m_program;
  22.     delete m_mesh;
  23.     delete m_glTexture;
  24.     delete m_fbo;
  25. }
  27. void DispersionEffect::onCreate()
  28. {
  29.     printf("%s: onCreate\n", TAG);
  30.     createProgram();
  31.     createTexture();
  32.     m_mesh = MeshUtils::createRect(true);
  33.     m_fbo = new FrameBufferObject(Format::RGBA8888(), app->width, app->height, false, false);
  34. }
  36. void DispersionEffect::onResize(int width, int height)
  37. {
  38.     printf("%s: onResize, width: %d, height: %d\n", TAG, width, height);
  39. }
  41. void DispersionEffect::onDraw(float runtime)
  42. {
  43.     m_fbo->begin();
  44.     m_program->bind();
  45.     m_program->setUniformf("u_time", runtime);
  46.     m_program->setUniformf("u_aspect", app->aspect);
  47.     m_glTexture->bind(m_program);
  48.     m_mesh->render(m_program, GL_TRIANGLES);
  49.     m_fbo->end();
  50. }
  52. void DispersionEffect::bind(ShaderProgram* shader)
  53. {
  54.     m_fbo->bind(shader);
  55. }
  57. void DispersionEffect::createProgram()
  58. {
  59.     printf("%s: createProgram\n", TAG);
  60.     const char* vertexCode = StringUtils::loadStringFromFile("assets/shaders/dispersion_vert.glsl");
  61.     const char* fragmentCode = StringUtils::loadStringFromFile("assets/shaders/dispersion_frag.glsl");
  62.     m_program = new ShaderProgram(vertexCode, fragmentCode);
  63. }
  65. void DispersionEffect::createTexture()
  66. {
  67.     printf("%s: createTexture\n", TAG);
  68.     BitmapData* data = BitmapUtils::loadBitmapDataFromFile("assets/textures/girl.jpg");
  69.     m_glTexture = new GLTexture(data->buffer, data->width, data->height);
  70. }
复制代码
4.3 JellyEffect

​    JellyEffect 是果冻特效。
​    jelly_effect.h
  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_effect.cpp
  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. }
复制代码
​    jelly_vert.glsl
  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. };
复制代码
​    jelly_frag.glsl
  1. #include <iostream>
  3. #include "glcore/core.h"
  5. #include "render/jelly_effect.h"
  6. #include "utils/string_utils.h"
  8. #define TAG "JellyEffect"
  10. using namespace glcore;
  12. JellyEffect::JellyEffect()
  13. {
  14.     printf("%s: init\n", TAG);
  15. }
  17. JellyEffect::~JellyEffect()
  18. {
  19.     printf("%s: destroy\n", TAG);
  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.     printf("%s: onCreate\n", TAG);
  32.     createProgram();
  33.     m_mesh = MeshUtils::createRect(false);
  34. }
  36. void JellyEffect::onResize(int width, int height)
  37. {
  38.     printf("%s: onResize, width: %d, height: %d\n", TAG, 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, GL_TRIANGLE_FAN);
  48. }
  50. void JellyEffect::createProgram()
  51. {
  52.     printf("%s: createProgram\n", TAG);
  53.     const char* vertexCode = StringUtils::loadStringFromFile("assets/shaders/jelly_vert.glsl");
  54.     const char* fragmentCode = StringUtils::loadStringFromFile("assets/shaders/jelly_frag.glsl");
  55.     m_program = new ShaderProgram(vertexCode, fragmentCode);
  56. }
复制代码
4.4 运行效果

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

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

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

使用道具 举报

相关推荐
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
卢莹洁
前天 11:20

0

粉丝关注

17

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫