[
{
"path": ".gitignore",
"content": ".DS_Store\n*.key\n*/images/*.log\nUnrealEngine4/Part3_AnimationSystem.md\nUnrealEngine4/Part4_LandscapeSystem.md\nUnrealEngine4/Part5_ParticleSystem.md\n"
},
{
"path": "ComputerGraphics(OpenGL)/EXT0_GLBuffers&MultiSample.md",
"content": "# 一、顶点信息传输\n\n## 1. 立即模式 glBegin()/glEnd()\n\n方式：立即绘制\n\n优点：功能适配范围广，写法直观\n缺点：频繁调用 OpenGL 函数，效率低，共享点使用次数多\n\n例子：\n\n1. 直接提交 OpenGL 命令到 GPU\n\n```c\n// Note that not all of OpenGL commands can be placed in between glBegin() and glEnd()\n// Only a subset of commands can be used\n// glVertex*(), glColor*(), glNormal*(), glTexCoord*(), glMaterial*(), glCallList(), etc.\nglBegin(GL_TRIANGLES);\n glColor3f(1, 0, 0); // set vertex color to red\n glVertex3fv(v1); // draw a triangle with v1, v2, v3\n glVertex3fv(v2);\n glVertex3fv(v3);\nglEnd();\n```\n\n2. 将命令放到 DisplayList 后，批量一次传入到 GPU\n DisplayList 会将其中命令的所有资源存储到自己的内存中\n DisplayList 是服务端的状态，本身存储在 GPU 缓存中，只能存储与服务端有关的部分命令\n DisplayList 的命令和数据一旦上传便不可修改\n\n```c\n// create one display list\nGLuint index = glGenLists(1);\n\n// compile the display list, store a triangle in it\n// Option: GL_COMPILE or GL_COMPILE_AND_EXECUTE(render)\nglNewList(index, GL_COMPILE);\n glBegin(GL_TRIANGLES);\n glVertex3fv(v0);\n glVertex3fv(v1);\n glVertex3fv(v2);\n glEnd();\nglEndList();\n...\n\n// draw the display list\nglCallList(index);\n...\n\n// delete it if it is not used any more\nglDeleteLists(index, 1);\n```\n\n\n\n## 2. VertexArray\n\n方式：批量数据传入绘制\n\n优点：数据以数组的形式**存储在应用缓存**，减少了 OpenGL 函数的频繁调用\n缺点：每次绘制都要占用带宽上传到显存\n\n例子：\n\n```c\nGLfloat vertices[] = {...}; // 36 of vertex coords\n\nglUseProgram(progId);\n\n// activate and specify pointer to vertex array\n// 因为 vertices 存储在应用程序上，所以这里 enable client state\nglEnableClientState(GL_VERTEX_ARRAY);\n// 也可以用 \n// glNormalPointer、glColorPointer、glIndexPointer、glTexCoordPointer、glEdgeFlagPointer\nglVertexPointer(3, GL_FLOAT, 0, vertices);\n\n// draw a cube\n// 也可以用 glDrawElements、glDrawRangeElements\nglDrawArrays(GL_TRIANGLES, 0, 36);\n\n// deactivate vertex arrays after drawing\nglDisableClientState(GL_VERTEX_ARRAY);\n```\n\n\n\n## 3. VertexBuffer\n\n方式：批量数据传入绘制\n\n优点：\n1. 数据以数组的形式**存储在显卡高速缓存**，每次使用时不用重新上传，只需要在显卡绑定即可\n2. 数据由于存储在显存，可以被应用程序在不同线程访问和修改\n\n例子：\n\n1. 创建和销毁\n\n```c\nGLuint vboId; // ID of VBO\nGLfloat* vertices = new GLfloat[vCount*3]; // create vertex array\n\n// generate a new VBO and get the associated ID\nglGenBuffers(1, &vboId);\n\n// bind VBO in order to use\n// Option: GL_ARRAY_BUFFER or GL_ELEMENT_ARRAY_BUFFER\n// This Option assists VBO to decide the most efficient locations of buffer objects\n// For example, some systems may prefer indices in AGP or system memory, and vertices in video memory\n// Once glBindBuffer() is first called, VBO initializes the buffer with a zero-sized memory buffer and set the initial VBO states, such as usage and access properties.\nglBindBuffer(GL_ARRAY_BUFFER, vboId);\n\n// upload data to VBO\n// Option: glBufferSubData, GL_[STATIC/DYNAMIC/STREAM]_[DRAW/READ/COPY]\n// GL_STATIC_DRAW 决定了数据的存储位置\n// Static: 更新一次，使用多次\n// Dynamic: 不断更新，使用多次\n// Stream: 更新一次，最多使用几次\n// Draw: application upload to GPU\n// Read: GPU copy to application\n// Copy: Draw and Read\nglBufferData(GL_ARRAY_BUFFER, dataSize, vertices, GL_STATIC_DRAW);\n\n// it is safe to delete after copying data to VBO\ndelete [] vertices;\n\n// delete VBO when program terminated\nglDeleteBuffers(1, &vboId);\n```\n\n2. 过去的使用方式：不同的 API 开启/关闭 不同的顶点属性\n```c\nglUseProgram(progId);\n\n// bind VBOs for vertex array and index array\nglBindBuffer(GL_ARRAY_BUFFER, vboId1); // for vertex attributes\nglBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboId2); // for indices\n\nglEnableClientState(GL_VERTEX_ARRAY); // activate vertex position array\nglEnableClientState(GL_NORMAL_ARRAY); // activate vertex normal array\nglEnableClientState(GL_TEXTURE_COORD_ARRAY); // activate texture coord array\n\n// do same as vertex array except pointer\nglVertexPointer(3, GL_FLOAT, stride, offset1); // last param is offset, not ptr\nglNormalPointer(GL_FLOAT, stride, offset2);\nglTexCoordPointer(2, GL_FLOAT, stride, offset3);\n\n// draw 6 faces using offset of index array\nglDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_BYTE, 0);\n\nglDisableClientState(GL_VERTEX_ARRAY); // deactivate vertex position array\nglDisableClientState(GL_NORMAL_ARRAY); // deactivate vertex normal array\nglDisableClientState(GL_TEXTURE_COORD_ARRAY); // deactivate vertex tex coord array\n\n// bind with 0, so, switch back to normal pointer operation\nglBindBuffer(GL_ARRAY_BUFFER, 0);\nglBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);\n```\n\n3. OpenGL 2.0 + 使用方式：同一个 API 开启/关闭 不同的顶点属性\n```c\nglUseProgram(progId);\n\n// bind VBOs for vertex array and index array\nglBindBuffer(GL_ARRAY_BUFFER, vboId1); // for vertex coordinates\nglBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboId2); // for indices\n\nglEnableVertexAttribArray(attribVertex); // activate vertex position array\nglEnableVertexAttribArray(attribNormal); // activate vertex normal array\nglEnableVertexAttribArray(attribTexCoord); // activate texture coords array\n\n// set vertex arrays with generic API\nglVertexAttribPointer(attribVertex, 3, GL_FLOAT, false, stride, offset1);\nglVertexAttribPointer(attribNormal, 3, GL_FLOAT, false, stride, offset2);\nglVertexAttribPointer(attribTexCoord, 2, GL_FLOAT, false, stride, offset3);\n\n// draw 6 faces using offset of index array\nglDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_BYTE, 0);\n\nglDisableVertexAttribArray(attribVertex); // deactivate vertex position\nglDisableVertexAttribArray(attribNormal); // deactivate vertex normal\nglDisableVertexAttribArray(attribTexCoord); // deactivate texture coords\n\n// bind with 0, so, switch back to normal pointer operation\nglBindBuffer(GL_ARRAY_BUFFER, 0);\nglBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);\n```\n\n4. 更新 VAO\n```c\n// 方法 1：重新向 GPU 上传数据（缺点：应用程序和 GPU 要存储 2 份数据，每次更新都要占用带宽）\nglBufferData(GL_ARRAY_BUFFER, dataSize, vertices, GL_STATIC_DRAW);\n\n// 方法 2：通过映射 GPU 上缓存数据地址到应用程序的缓存地址\n// 将应用程序对地址的操作用于对 GPU 缓存操作，达到在应用程序控制 GPU 缓存的效果\n\n// bind then map the VBO\nglBindBuffer(GL_ARRAY_BUFFER, vboId);\n\n// Option: GL_READ_ONLY, GL_WRITE_ONLY, GL_READ_WRITE\n// 如果 GPU 正在使用这个 buffer，将会返回 NULL\nfloat* ptr = (float*)glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);\n\n// if the pointer is valid(mapped), update VBO\nif(ptr)\n{\n updateMyVBO(ptr, ...); // custom function modify buffer data\n glUnmapBuffer(GL_ARRAY_BUFFER); // unmap it after use it's return GLboolean\n}\n```\n\n\n\n# 二、Pixel Buffer\n\n## 1. 创建和使用\n\nPixel Buffer Object 由 Vertex Buffer Object 扩展而来，因此对 Pixel Buffer 操作的许多细节和接口都与 Vertex Buffer 保持一致，这里不在赘述\n\n例子：\n\n```c\nGLuint pboIds[2];\n\n// Create\nglGenBuffers(2, pboIds);\n\n// Bind\n// Option: GL_PIXEL_UNPACK_BUFFER / GL_PIXEL_PACK_BUFFER\nglBindBuffer(GL_PIXEL_UNPACK_BUFFER, pboIds[0]);\n// load data rgba\nglBufferData(GL_PIXEL_UNPACK_BUFFER, 720 * 1280 * 4, NULL, GL_STREAM_DRAW);\n// unbind\nglBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);\n...\n\n// Note that glMapBuffer() causes sync issue\n// If GPU is working with this buffer, glMapBuffer() will wait(stall)\n// until GPU to finish its job. To avoid waiting (idle), you can call\n// first glBufferData() with NULL pointer before glMapBuffer()\n// If you do that, the previous data in PBO will be discarded and\n// glMapBuffer() returns a new allocated pointer immediately\n// even if GPU is still working with the previous data\nglBufferData(GL_PIXEL_UNPACK_BUFFER, 720 * 1280 * 4, NULL, GL_STREAM_DRAW);\n\n// Mapping PBO\nglBindBuffer(GL_PIXEL_UNPACK_BUFFER, pboIds[0]);\nGLubyte* ptr = (GLubyte*)glMapBuffer(GL_PIXEL_UNPACK_BUFFER, GL_WRITE_ONLY);\nif(ptr)\n{\n // Custom function: update data directly on the mapped buffer\n updatePixels(ptr, DATA_SIZE);\n // release pointer to mapping buffer\n glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER);\n}\n\n// Delete PBO\nglDeleteBuffers(1, &pboIds);\n```\n\n\n\n## 2. PBO、FBO、Texture Object\n\n\n\n**Pack（OpenGL to Application）**\n**glReadPixels**\n\n1. 从 frame buffer 中读取数据\n2. 将 frame buffer 数据写入 Pixel buffer\n\n\n\n**Unpack（Application to OpenGL）**\n**glDrawPixels**\n\n1. 从 Pixel buffer 读取数据\n2. 将 Pixel buffer 数据写入 frame buffer\n\n\n\n## 3. Direct Memory Access\n\n将数据转换到 Pixel Buffer Object 很快是由于：转到 PBO 的数据将会直接进入显卡缓存中，不通过 CPU 的调度\n\n例如在加载纹理时：\n\n1. 不使用 PBO\n 在 CPU 的调度下，将图片资源加载到系统缓存，然后从系统缓存拷贝到 OpenGL 的纹理对象\n2. 使用 PBO\n 直接加载到 OpenGL 里的 PBO 下，然后拷贝到纹理对象\n 整个过程由 GPU 完成，可以和 CPU 异步执行，效率提高\n\n\n\n例子：\n\n普通加载纹理的方式\n\n```c\n// Data is from CPU memory\nglBindTexture(GL_TEXTURE_2D, textureId);\nglTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA, width, height, 0, GL_BGRA, GL_UNSIGNED_BYTE, data);\n```\n\n\n\n通过 PBO 加载纹理（PBO 创建时已经加载纹理数据）\n\n```c\n// bind the texture and PBO\nglBindTexture(GL_TEXTURE_2D, textureId);\nglBindBuffer(GL_PIXEL_UNPACK_BUFFER, pboIds[index]);\n\n// copy pixels from PBO to texture object so the last param is 0 not data\n// Use offset instead of pointer\nglTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, GL_BGRA, GL_UNSIGNED_BYTE, 0);\n\n// it is good idea to release PBOs with ID 0 after use\n// Once bound with 0, all pixel operations are back to normal ways\nglBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);\n```\n\n\n\n通过 PBO 加载/读取 Frame Buffer\n\n```c\n// set the target framebuffer to read\nglReadBuffer(GL_FRONT);\n\n// read pixels from framebuffer to PBO\n// glReadPixels() should return immediately.\nglBindBuffer(GL_PIXEL_PACK_BUFFER, pboIds[index]);\nglReadPixels(0, 0, WIDTH, HEIGHT, GL_BGRA, GL_UNSIGNED_BYTE, 0);\n```\n\n\n\n\n\n# 三、Frame Buffer\n\n> 定义：framebuffer 是 OpenGL 一系列数据存储的集合\n\n**浮点帧缓冲 (Floating Point Framebuffer)**\n当一个帧缓冲的颜色缓冲的内部格式被设定成了 `GL_RGB16F`, `GL_RGBA16F`, `GL_RGB32F` 或者 `GL_RGBA32F` 时，这些帧缓冲被叫做，浮点帧缓冲可以存储超过 0.0 到 1.0 范围的浮点值\n\n当帧缓冲使用了一个标准化的定点格式(像 `GL_RGB` )为其颜色缓冲的内部格式，OpenGL 会在将这些值存入帧缓冲前自动将其约束到 0.0 到 1.0 之间\n\n\n\n## 1. 不同种类的 framebuffer\n\n1. **Default framebuffer**\n 本地窗口系统创建和使用的 framebuffer，一定会显示到屏幕上，是本地系统创建 Context 的一部分，当 `glBindFramebuffer(GL_FRAMEBUFFER, 0);` 时，绑定的就是当前窗口系统提供的 default framebuffer\n 这种 framebuffer 有本地窗口系统 API 创建提供，由 OpenGL 将其作为自己的输出给本地窗口系统来使用\n 包含：多个（至少一个）色彩缓冲、一个深度缓冲、一个模板缓冲、一个累积缓冲\n 2. **Frame Buffer Object**\n OpenGL 创建和使用的 framebuffer，可以不显示到屏幕上\n 提供一个 FBO 对象来供 OpenGL 操作，FBO 对象可以有**多个（至少一个）色彩缓冲**，一个深度缓冲，一个模板缓冲（没有累积缓冲）\n\n\n\n## 2. 内部数据对象\n\n> framebuffer 提供的内部数据都以 attach 方式来赋予，并非内部创建\n> 因此 framebuffer 内部数据的切换都要比单独切换 framebuffer 本身要快\n\n切换 texture：**glFramebufferTexture2D**\n\n1. attach 的 textureid 为 0，之前的纹理将会从 frame buffer 上解绑\n2. 删除纹理时会自动从当前绑定的 framebuffer 上解绑，但如果当前纹理并不会从其他已 attach 的**非当前绑定的** framebuffer 解绑\n\n\n\n切换 renderbuffer：**glFramebufferRenderbuffer**\n1. renderbuffer 主要用来存储一些逻辑数据，而非图像数据\n\n2. 可以通过 glGetRenderbufferParameteriv 来获取 renderbuffer 里数据的一些属性\n\n ```c\n int width;\n // Option: \n // GL_RENDERBUFFER_WIDTH\n // GL_RENDERBUFFER_HEIGHT\n // GL_RENDERBUFFER_INTERNAL_FORMAT\n // GL_RENDERBUFFER_RED_SIZE\n // GL_RENDERBUFFER_GREEN_SIZE\n // GL_RENDERBUFFER_BLUE_SIZE\n // GL_RENDERBUFFER_ALPHA_SIZE\n // GL_RENDERBUFFER_DEPTH_SIZE\n // GL_RENDERBUFFER_STENCIL_SIZE\n glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_WIDTH, &width);\n ```\n\n \n\n## 3. 创建和使用\n\n例子：\n\n```c\nGLuint fboId;\n\n// create a framebuffer object, you need to delete them when program exits.\nglGenFramebuffers(1, &fboId);\nglBindFramebuffer(GL_FRAMEBUFFER, fboId);\n\n// create a renderbuffer object to store depth info\n// NOTE: A depth renderable image should be attached the FBO for depth test.\n// If we don't attach a depth renderable image to the FBO, then\n// the rendering output will be corrupted because of missing depth test.\n// If you also need stencil test for your rendering, then you must\n// attach additional image to the stencil attachement point, too.\nglGenRenderbuffers(1, &rboDepthId);\nglBindRenderbuffer(GL_RENDERBUFFER, rboDepthId);\n// allocat memory for renderbuffer\nglRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, TEXTURE_WIDTH, TEXTURE_HEIGHT);\n//glRenderbufferStorageMultisample(GL_RENDERBUFFER, fboSampleCount, GL_DEPTH_COMPONENT, TEXTURE_WIDTH, TEXTURE_HEIGHT);\nglBindRenderbuffer(GL_RENDERBUFFER, 0);\n\n// attach a texture to FBO color attachement point\nglFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, textureId, 0);\n//glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, textureId, 0);\n\n// attach a renderbuffer to depth attachment point\nglFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rboDepthId);\n\n//@@ disable color buffer if you don't attach any color buffer image,\n//@@ for example, rendering the depth buffer only to a texture.\n//@@ Otherwise, glCheckFramebufferStatus will not be complete.\n//glDrawBuffer(GL_NONE);\n//glReadBuffer(GL_NONE);\n\n// trigger mipmaps generation explicitly\n// NOTE: If GL_GENERATE_MIPMAP is set to GL_TRUE, then glCopyTexSubImage2D()\n// triggers mipmap generation automatically. However, the texture attached\n// onto a FBO should generate mipmaps manually via glGenerateMipmap().\nglBindTexture(GL_TEXTURE_2D, textureId);\nglGenerateMipmap(GL_TEXTURE_2D);\nglBindTexture(GL_TEXTURE_2D, 0);\n```\n\n\n\n## 4. Multi Sample Anti Aliasing\n\n多重采样抗锯齿功能**不会自动打开**\n\n例子\n\n```c\n// Open MSAA\nglEnable(GL_MULTISAMPLE); // default is enable\n\n// create a 4x MSAA renderbuffer object for colorbuffer\nint msaa = 4;\nGLuint rboColorId;\nglGenRenderbuffers(1, &rboColorId);\nglBindRenderbuffer(GL_RENDERBUFFER, rboColorId);\nglRenderbufferStorageMultisample(GL_RENDERBUFFER, msaa, GL_RGB8, width, height);\n\n// create a 4x MSAA renderbuffer object for depthbuffer\nGLuint rboDepthId;\nglGenRenderbuffers(1, &rboDepthId);\nglBindRenderbuffer(GL_RENDERBUFFER, rboDepthId);\n// msaa: samples count\n// get max count by use glGetIntegerv(GL_MAX_SAMPLES, &max_samples_count);\nglRenderbufferStorageMultisample(GL_RENDERBUFFER, msaa, GL_DEPTH_COMPONENT, width, height);\n\n// create a 4x MSAA framebuffer object\nGLuint fboMsaaId;\nglGenFramebuffers(1, &fboMsaaId);\nglBindFramebuffer(GL_FRAMEBUFFER, fboMsaaId);\n\n// attach colorbuffer image to FBO\nglFramebufferRenderbuffer(GL_FRAMEBUFFER, // 1. fbo target: GL_FRAMEBUFFER\n GL_COLOR_ATTACHMENT0, // 2. color attachment point\n GL_RENDERBUFFER, // 3. rbo target: GL_RENDERBUFFER\n rboColorId); // 4. rbo ID\n\n// attach depthbuffer image to FBO\nglFramebufferRenderbuffer(GL_FRAMEBUFFER, // 1. fbo target: GL_FRAMEBUFFER\n GL_DEPTH_ATTACHMENT, // 2. depth attachment point\n GL_RENDERBUFFER, // 3. rbo target: GL_RENDERBUFFER\n rboDepthId); // 4. rbo ID\n```\n\n\n\n### 4.1 多重采样 转 单采样\n\n**多重采样后 framebuffer 的渲染结果不能直接使用，需要转换成 single-sample image 才能使用**\n\n转换例子\n\n```c\n// copy rendered image from MSAA (multi-sample) to normal (single-sample)\n// NOTE: The multi samples at a pixel in read buffer will be converted\n// to a single sample at the target pixel in draw buffer.\nglBindFramebuffer(GL_READ_FRAMEBUFFER, fboMsaaId); // src FBO (multi-sample)\nglBindFramebuffer(GL_DRAW_FRAMEBUFFER, fboId); // dst FBO (single-sample)\n\nglBlitFramebuffer(0, 0, width, height, // src rect\n 0, 0, width, height, // dst rect\n GL_COLOR_BUFFER_BIT, // buffer mask(which buffers are copied)\n GL_LINEAR); // scale filter\n```\n\n\n\n### 4.2 从 shader 里获取多重采样结果\n\n```c\n// shader 里自定义多重纹理采样\n\n// 1. 使用 sampler2DMS 而不是 sampler2D\nuniform sampler2DMS screenTextureMS; \n\n// 2. 使用 texelFetch\nvec4 colorSample = texelFetch(screenTextureMS, TexCoords, 3); // 取第4个子样本\n```\n\n\n\n\n\n## 5. 检查 framebuffer 的状态\n\n例子\n\n```c\nbool checkFramebufferStatus(GLuint fbo)\n{\n // check FBO status\n glBindFramebuffer(GL_FRAMEBUFFER, fbo); // bind\n GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);\n switch(status)\n {\n case GL_FRAMEBUFFER_COMPLETE:\n std::cout << \"Framebuffer complete.\" << std::endl;\n return true;\n\n case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:\n std::cout << \"[ERROR] Framebuffer incomplete: Attachment is NOT complete.\" << std::endl;\n return false;\n\n case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:\n std::cout << \"[ERROR] Framebuffer incomplete: No image is attached to FBO.\" << std::endl;\n return false;\n/*\n case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS:\n std::cout << \"[ERROR] Framebuffer incomplete: Attached images have different dimensions.\" << std::endl;\n return false;\n\n case GL_FRAMEBUFFER_INCOMPLETE_FORMATS:\n std::cout << \"[ERROR] Framebuffer incomplete: Color attached images have different internal formats.\" << std::endl;\n return false;\n*/\n case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER:\n std::cout << \"[ERROR] Framebuffer incomplete: Draw buffer.\" << std::endl;\n return false;\n\n case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER:\n std::cout << \"[ERROR] Framebuffer incomplete: Read buffer.\" << std::endl;\n return false;\n\n case GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE:\n std::cout << \"[ERROR] Framebuffer incomplete: Multisample.\" << std::endl;\n return false;\n\n case GL_FRAMEBUFFER_UNSUPPORTED:\n std::cout << \"[ERROR] Framebuffer incomplete: Unsupported by FBO implementation.\" << std::endl;\n return false;\n\n default:\n std::cout << \"[ERROR] Framebuffer incomplete: Unknown error.\" << std::endl;\n return false;\n }\n glBindFramebuffer(GL_FRAMEBUFFER, 0); // unbind\n}\n```\n\n\n\n\n\n# Reference\n\n1. [OpenGL Vertex Buffer Object (VBO)](http://www.songho.ca/opengl/gl_vbo.html)\n2. [How to choose between GL_STREAM_DRAW or GL_DYNAMIC_DRAW?](https://stackoverflow.com/questions/8281653/how-to-choose-between-gl-stream-draw-or-gl-dynamic-draw)\n3. [OpenGL Pixel Buffer Object](http://www.songho.ca/opengl/gl_pbo.html)\n4. [OpenGL Frame Buffer Object](http://www.songho.ca/opengl/gl_fbo.html)"
},
{
"path": "ComputerGraphics(OpenGL)/EXT1_FileFormat.md",
"content": "# 一、图片存储格式\n\n## 1. BMP 文件\n\n无损的图片格式，全称 Bitmap（无压缩，体积大）\n可以直接存储图片数据，也可以采用索引表的存储方式。但即便采用了索引表的存储方式，也不能使体积缩小太多。图片的内存格式\n\n适合：logos 等有明确边界的图片，程序的缓存文件（无压缩，可直接存储的特点）\n\n格式：ARGB，BMP 文件的第一行数据是显示器的最后一行数据\n\n内存排列：\n\n- 位图文件头(bitmap-file header)\n\n- 位图信息头(bitmap-informationheader)\n\n- 颜色表(color table)\n\n- 颜色点阵数据(bits data)\n\n \n\n## 2. GIF 文件\n\n无损的图片压缩格式，只能采用索引表的存储方式存储，因此最多能表示 256 种颜色\nGIF 的图片善于做动画，并且支持 alpha 透明通道\n\n适合：logos 等有明确边界的简单图片\n\n\n\n## 3. PNG 文件\n\nPortable Network Graphics\n无损的图片压缩格式，不能做动画，支持 alpha 透明通道（透明效果优于 GIF）\n\n- PNG-8：采用索引表的方式存储图片，最多能表示 256 种颜色（压缩后体积小于 GIF）\n 适合：logos 等有明确边界的简单图片\n- PNG-24：采用直接存储的方式存储图片，能存储上千种颜色（24 位存储一个像素）\n 适合：兼顾好的压缩和效果的照片存储\n\n\n\n## 4. JPEG 文件\n\nJoint Photographic Experts Group\n简称 jpg，有损的图片压缩格式，压缩后体积小（虽然有损，但不易被人眼察觉，24 位存储一个像素 RGB，**不支持透明**）\n适合：只考虑体积照片的压缩\n\nJPEG 格式图片是分为一个一个的段来存储的：\n段的多少和长度并不是一定的。只要包含了足够的信息，该 JPEG 文件就能够被打开，呈现给人们\n\n段的结构：\n\n```c++\n名称 字节数 数据 说明\n------------------------------------------------------\n段标识 1 FF 每个新段的开始标识\n段类型 1 类型编码（称作“标记码”）\n段长度 2 包括段内容和段长度本身,不包括段标识和段类型\n段内容 ≤65533字节\n```\n\n\n\nJPEG 图片存储的段文件按顺序依次如下：\n\n1. **SOI（文件头）**Start Of Image\n 段标识：FF（标志新段的开始）\n 段类型：D8（SOI 的段类型为 D8，表示文件头）\n2. APP0（图像识别信息）Application data marker, type 0\n 段标识：FF（标志新段的开始）\n 段类型：E0（APP0 的段类型为 E0，定义交换格式和图像识别信息）\n3. DQT（定义量化表）\n4. SOF0（图像基本信息）\n5. DHT（定义 Huffman 表）\n6. DRI（定义重新开始间隔）\n7. SOS（扫描行开始）\n8. **EOI（文件尾）**End Of Image\n 段标识：FF（标志新段的开始）\n 段类型：D9（EOI 的段类型为 D9 表示文件尾）\n\n\n\n## 5. SVG 文件\n\n矢量的图片存储方案，内部存储的不是像素，而是曲线和线条\n这使得即便是看起来很大的 SVG 图，存储起来会很小（前提是画面图像足够简单）\nSVG 使用 XML 语法编写，并且可以在文本工具里修改（可以使用 JavaScript 快速修改 SVG 图片的颜色）\n\n适合：logos 或 icons 等简单且需要适配不同尺寸的网站图片\n\n\n\n\n## 6. TGA 文件\n\n游戏中常用的图像格式\n\n### 6.1 非压缩文件格式\n\n\n\n### 6.2 压缩文件格式\n\n\n\n\n\n\n\n# 二、三维文件格式\n\n三维软件之间互相导入导出一般会涉及到一些格式不兼容的问题，不同的格式有着不同的定位及用处，有开源的也有商业的\n\n| 格式 | 功能 | 详情 |\n| ---------------------------------------- | ------------------------------------------------------------ | ------------------------------------------------------------ |\n| **.abc**
Alembic | 动画、粒子、模型烘焙、流体 | 通用格式，有效地储存, 共享动画与特效场景
[官网](http://www.alembic.io/)
[为什么 CG 行业需要 Alembic（.abc） 通用格式](http://www.bgteach.com/article/131) |\n| **.glTF**
GL Transmission Format | 动画、场景、相机、网格、材质、纹理、着色器、着色程序 | json 格式描述
较少的冗余信息
[官网](https://www.khronos.org/gltf/)
[Github](https://github.com/KhronosGroup/glTF/blob/master/README.md) |\n| **.fbx**
FilmBoX | 骨骼动画、材质、网格 | FilmBoX 这套软件所使用的格式，后改称 Motionbuilder
Autodesk 家族格式，在 3D Max、Maya、Softimage 等软件间进行**模型**、材质、**动作**和摄影机信息的互导，这样就可以发挥 3D Max 和 Maya 等软件的优势 |\n| **.bvh**
BioVision | 骨骼动画 | 对人体运动进行捕获后产生文件格式的文件扩展名，捕捉后的文件可以重复利用，应用在不同的角色骨骼驱动上制作动画 |\n| **.obj** | 主要支持多边形(Polygons)模型
不包含动画、材质特性、贴图路径、动力学、粒子等信息 | 几乎所有知名的 3D 软件都支持 OBJ 文件的读写 |\n| **.ply**
Polygon File Format | 静态多边形模型，OBJ 格式的升级版
颜色、透明度、表面法向量、材质座标与资料可信度 | 改进了 Obj 格式所缺少的对任意属性及群组的扩充性
因此PLY格式发明了 \"property\" 及 \"element\" 这两个关键词，来概括 \"顶点、面、相关资讯、群组\" 的概念 |\n| **.dae**
Data Acquisition Equipment | 骨骼动画、材质、网格 | xml 格式描述，3D Max、Maya，通过安装插件可导出
相比 FBX，对 dae 格式模型的载入有非常高的自由控制，是 FBX 格式代替品 |\n| **.x3d** | 多纹理、多遍绘制、支持 Shader 着色、支持多渲染目标、支持几何实例 | xml 格式描述，专为万维网而设计的三维图像标记语言 |\n| **.stl** | 三角面静态模型
只能描述三维物体的几何信息，不支持颜色材质等信息 | 计算机图形学处理 CG、数字几何处理如 CAD、 数字几何工业应用, 如三维打印机支持的最常见文件格式 |\n| **.dxf**
Drawing Exchange File | 三角面静态模型 | CAD 通用格式 |\n| **.3ds** | 三角面静态模型 | 比较早的一种三维格式，三角面，最早游戏模型应用比较广泛
由于后期导入软件的不可编辑性、难以二次编辑现在逐渐的远离了我们的视线 |\n\n\n\n# 三、三维软件\n\n三维软件根据工作的功能分类为：\n\n- 主体三维软件\n 指能独立完成整个三维动画创作的平台性三维软件，具备建模、材质、灯光、渲染、动画、角色等一系列创作的需求，同时允许开发者对软件进行开发第三方插件以扩充软件主体的三维软件\n \n | 软件 | 简介 | 功能 |\n | --------- | ---------------------------------- | ------------------------------------------------------------ |\n | Blender | 免费开源的三维软件 | 建模、材质、灯光、渲染、雕刻、角色动画、纹理绘制、插件、摄影机跟踪、扣像、合成、游戏引擎 |\n | Maya | 售价高昂，易学易用，制作效率高 | 建模、材质、灯光、渲染、角色动画、插件 |\n | Cinema 4D | 许多一流艺术家和电影公司的首选 | 建模、材质、灯光、渲染、雕刻、角色动画、纹理绘制、插件 |\n | Houdini | 完全是为电影而生 | 建模、材质、灯光、渲染、特效、角色动画 |\n | LightWave | 生物建模和角色动画方面功能异常强大 | 建模、材质、灯光、渲染、特效、角色动画 |\n | Softimage | 2014 年三月，发布停产声明 | 建模、材质、灯光、渲染、特效、角色动画 |\n\n \n \n- 协助三维软件\n 指能依赖三维主体软件存在，以强大的辅助完成高质量、高效率的流程，这种软件常常也属于单功能三维软件\n\n | 软件 | 简介 | 功能 |\n | ------------ | -------------------------------------------------------- | --------------------------------------------------------- |\n | Clarisse iFX | 以图像为核心
减少机器开始渲染最终图像所需的交互时间 | 导入模型、材质、灯光、即时渲染、特效、合成 |\n | Twinmotion | 可以将项目导出为 .exe 可执行文件 | 导入模型、材质、灯光、即时渲染、动画、展示、交互、VR、360 |\n | Lumion | 实时3D可视化工具
用来制作电影和静帧作品 | 导入模型、材质、灯光、即时渲染、动画、展示、360 |\n | ZBrush | 数字雕刻和绘画软件 | 雕刻、纹理 |\n\n\n\n\n- 单功能三维软件\n 一般在某个模块异常强大，由于着重解决流程中的一个环节，在效率上有着得天独厚的优势。 缺点也显而易见，需要主体三维软件的导入导出\n\n | 软件 | 简介 | 功能 |\n | -------------------- | ------------------------------------ | ------------------------------------------------------------ |\n | Marmoset Toolbag | 实时材质编辑，渲染，动画编辑预览软件 | GPU、CPU 即时渲染器 |\n | Silo | 视频游戏及电影创建角色或建筑 | 建模、UV Mapping |\n | Cycles Render Engine | blender 中的一种渲染引擎 | 基于光线追踪的渲染引擎，支持交互式渲染，内置一个新的光影节点系统、新的纹理工作流程和GPU加速，用户通过切换GPU渲染可以使渲染过程变得较为便捷 |\n\n\n\n\n\n# Reference\n\n- [What are the different usecases of PNG vs. GIF vs. JPEG vs. SVG?](https://stackoverflow.com/questions/2336522/what-are-the-different-usecases-of-png-vs-gif-vs-jpeg-vs-svg)\n\n- [libpng](http://www.libpng.org/pub/png/libpng.html)\n\n- [www.w3.org/Graphics](https://www.w3.org/Graphics/JPEG/itu-t81.pdf)\n\n- [JPEG 解码器](https://zhuanlan.zhihu.com/p/27296876)\n\n- [使用 libjpeg 进行图片压缩](https://zhuanlan.zhihu.com/p/126728039)\n\n- [影像算法解析——JPEG 压缩算法](https://zhuanlan.zhihu.com/p/40356456)\n\n- [TGA 文件格式解析](http://www.twinklingstar.cn/2013/471/tga-file-format/)\n\n- [三维文件格式知多少 ](http://www.bgteach.com/article/132)\n\n- [三维软件知多少](http://www.bgteach.com/article/40)\n\n- [图片文件格式知多少 | jpeg、png、pdf、tga、tif、svg、esp、exr、hdr...](https://www.bgteach.com/article/133)\n\n- [游戏制作行业为什么使用TGA格式的贴图而不使用PNG格式？ - 韦易笑的回答 - 知乎 ](https://www.zhihu.com/question/340196227/answer/789538293)\n\n \n\n"
},
{
"path": "ComputerGraphics(OpenGL)/EXT2_HardwareSupport.md",
"content": "# 一、 GPU 的硬件架构\n\nGPU 主要由 **显存 Device Memory** 和 **流多处理器 Stream Multiprocessors ** 组成（Stream Processors，SP 是 SM 中的一个 Core）\n\n\n\n## 1. CPU vs GPU\n\n相对于全面功能考虑的 CPU，GPU 有更多的 ALU（Arithmetic Logic Unit，逻辑运算单元），更少的逻辑控制单元和寄存器\nGPU 的并行运算：与 CPU 上十几个线程的并行计算不同，GPU 的线程数可以达到上百万或更多\n\n\n\n**缓存行 Cache-line**：缓存存储数据的最小单位\n\nCPU 主要采用**三层**缓存（当今主流的 CPU 架构）\n\n1. L1、L2 硬件缓存成为本地核心内缓存，即一个核一个\n 如果是 4 核，那就是有 4 个 L1+4 个 L2\n2. L3 硬件缓存是所有核共享的。即不管你的 CPU 是几核，这个 CPU 中只有一个 L3\n3. L1 硬件缓存的大小是 64K，即 32K 指令缓存 +32K 数据缓存，L2 是 256K，L3 是 2M\n 这不是绝对的，目前 Intel CPU 基本是这样的设计\n\n\n\nGPU 主要采用**二层**缓存（缓存容量小，Cache 命中率低，延时较高）\n\n1. L1 硬件缓存，速度最快，存储共享内存\n 每个 SM 独立包含，一部分在 SM 内共用，一部分在每个 SP 内单独使用（用来交换共享内存）\n2. L2 硬件缓存，速度低于 L1，存储只读常量、纹理\n 多个 SM 共享使用\n3. GPU 的全局内存最大为 12GB\n GPU 内存**不支持并发读取和并发写入**\n\n\n\n\n\n## 2. Stream Multiprocessor\n\nGPU 在 shader 中进行的向量运算采用 SIMD 或 MIMD 计算方式\n\n- **SISD**（Single Instruction Single Data Stream，单指令单数据流）：传统顺序执行计算机使用\n- **MIMD**（Multiple Instruction Stream Multiple Data Stream，多指令多数据流）：现代大多数计算机使用，使用多个控制器来异步地控制多个处理器，从而实现空间上的并行性。从硬件角度看，MIMD 需要消耗大量的晶体管数\n- **SIMD**（Single Instruction Stream Multiple Data Stream，单指令多数据流）：GPU 内置计算方式，CPU 里也有相应的实现方法\n- **MISD**（Multiple Instruction Stream Single Data Stream，多指令单数据流）\n\n\n\n早期的 GPU，顶点着色器和像素着色器的硬件结构是独立的（顶点和像素线程资源不能共享）\n使用统一着色器架构 **Unified shader Architecture**，VS、PS、GS、CS 都可以使用相同的硬件资源（线程共享）Stream Multiprocessor\n\n\n Stream Multiprocessor，SM 为 Shader 执行的地方，如右图一个多流处理器包含\n 
\n
\n\n1. **多边形引擎 PolyMorph Engine**：负责 attribute Setup、VertexFetch、曲面细分、栅格化\n2. **多 ALU 逻辑运算 Core**（每个核代表一个线程，由 Warp 统一管理一组线程）\n Warp 中的多个线程是**单指令多线程**（相同的逻辑，不同的数据）\n 当执行 if-else 语句、 for 循环次数 n 不是常量，或被 break 提前终止了但其他批次循环的内容还在执行时\n 一个 Warp 线程组只会有部分满足逻辑条件的线程在执行，其他线程当前执行阶段会什么都不执行（被遮掩，但是仍然活跃）\n 这相当于浪费了一部分线程资源，导致像 if-else 这样的语句是 false 的情况也占用了线程资源（占用了，但不使用）\n3. **指令缓存 Instruction Cache**\n4. **LD/ST（load/store）**：加载和存储数据\n5. **SFU（Special function units）**：执行特殊数学运算（sin、cos、log 等）\n6. **寄存器** 128KB\n7. **L1 Cache**\n 配合共享的 L2 Cache 做到 vertex-shader 和 pixel-shader 的数据通信\n8. **Uniform Buffer** 的**部分**缓存\n9. **Texture Cache 和 纹理读取单元**\n\n\n\n## 3. GPU 处理 Shader\n\n**Shader 处理流程**\n\n1. CPU 端编译 Shader 源码为二进制（现代 GPU Shader 为二进制）\n2. CPU 端将 shader 二进制指令经由 PCI-e 推送到 GPU 端\n3. GPU 在执行代码时，会用 Context 将指令分成若干 Channel 推送到各个 SM 的存储空间\n\n\n\n**Shader 的流水线多线程式处理**\n\n多个 SP 里的多个运算单元同时运行同一个 Shader，但每个运算单元支撑的 1 个线程处理的数据又各不相同\n\n\n\n\n\n\n\n# 二、CPU、GPU、显示器\n\n## 1. CPU-GPU 异构系统\n\n\n\n**分离式**结构（左图）\n\n- 结构：CPU 和 GPU 拥有各自的存储系统，两者通过 PCI-e 总线进行连接，可以共享一套虚拟地址空间，必要时会进行内存拷贝\n\n- 缺点：PCI-e 相对于两者具有低带宽和高延迟，数据的**传输带宽**成了其中的性能瓶颈\n- 应用的硬件设备：**PC**（CPU、GPU 存储**各自有存储系统**）、**移动端**（CPU、GPU **继承到了一个芯片，且共享物理内存**）\n 很多 SoC （比如：移动端）都是集成了CPU 和 GPU，事实上这仅仅是在物理上进行了集成，并不意味着它们使用的（运行时）就是耦合式结构\n\n\n\n**耦合式**结构（右图）\n\n- 结构：CPU 和 GPU 集成到了一个芯片，GPU 没有独立的内存，与 GPU 共享系统内存，由 MMU 进行存储管理\n- 应用的硬件设备：PS4\n\n\n\n## 2. CPU-GPU Workflow\n\n下图所示为 CPU-GPU 异构系统的工作流，当 CPU 遇到图像处理的需求时，会调用 GPU 进行处理，主要流程可以分为以下四步：\n\n1. 将主存的处理数据 CPU 复制到 显存 GPU 中（可以通过 [DMA](./EXT0_GLBuffers&MultiSample.md) 跳过此步骤）\n2. CPU 指令驱动 GPU\n3. GPU 中的每个运算单元并行处理\n4. GPU 将显存结果传回主存\n\n\n\n\n\n## 3. CPU-GPU Data transmission\n\n\n\n1. **MMIO（Memory-Mapped I/O）**\n CPU 通过 MMIO 访问 GPU 的寄存器状态\n 通过 MMIO 传送数据块传输命令，支持 DMA 的硬件可以实现块数据传输\n\n2. **GPU Context**\n 上下文表示 GPU 的计算状态，在 GPU 中占据部分虚拟地址空间\n 多个活跃态下的上下文可以在 GPU 中并存（一个 Context 对应一个 SP）\n\n3. **CPU Channel**\n 来自 CPU 操作 GPU 的命令存储在内存中，并提交至 GPU channel 硬件单元\n 每个 GPU 上下文可拥有多个 GPU Channel\n 每个 GPU 上下文都包含 GPU channel 描述符（GPU 内存中的内存对象）\n 每个 GPU Channel 描述符存储了channel 的配置，如：其所在的页表\n 每个 GPU Channel 都有一个专用的命令缓冲区，该缓冲区分配在 GPU 内存中，通过 MMIO 对 CPU 可见\n\n4. **GPU 页表**\n GPU 上下文使用 GPU 页表进行分配，该表将**虚拟地址**空间与**其他地址空间**隔离开来\n GPU 页表与 CPU 页表分离，其驻留在 GPU 内存中，物理地址位于 GPU 通道描述符中\n 通过 GPU channel 提交的所有命令和程序都在对应的 GPU 虚拟地址空间中执行\n GPU 页表将 GPU 虚拟地址不仅转换为 GPU 设备物理地址，还转换为主机物理地址\n 这使得 GPU 页面表能够将 GPU 存储器和主存储器统一到统一的 GPU 虚拟地址空间中，从而构成一个完成的虚拟地址空间\n\n5. **PFIFO Engine**\n 一个提交 GPU 命令的特殊引擎\n 维护多个独立的命令队列，即 channel（带有 put 和 get 指针的环形缓冲器）\n 会拦截多有对通道控制区域的访问以供执行\n GPU 驱动使用一个通道描述符来存储关联通道的设置\n\n6. **Buffer Object** 缓冲对象\n 一块内存，可以用来存储纹理，渲染对象，着色器代码等等\n\n\n\n## 4. 显示器的显示\n\n从 CPU 通过 GPU 到显示的流程如下：\n\n1. CPU 计算好显示内容提交至 GPU\n2. GPU 渲染完成后将渲染结果存入帧缓冲区\n3. 视频控制器会按照 `VSync` 信号逐帧读取帧缓冲区的数据\n4. 帧缓冲区数据 经过转换后 由显示器进行显示\n\n\n\n**显示器显示工作流程**\n\n1. 显示器逐行刷新，每一行刷新完后会发出一个水平同步信号（horizonal synchronization），简称 **HSync**\n2. 绘制下一行\n3. 显示器一帧画面绘制完成后会发出一个垂直同步信号（vertical synchronization），简称 **VSync**\n\n\n\n**双缓冲机制**\n\n- 使用场景：防止在快速运动场景下，由于**显卡运算速率 > 显示器运算速率**导致快速运动的动作割裂情况（画面撕裂）\n- 方法：使用两个帧缓冲，一个负责 GPU 写入，一个负责 显示器 读取，用垂直同步确保写入完成后将写入和读取帧缓冲互换角色\n- 缺点：开启垂直同步，画面会有延迟（无法达到显卡的最大运算速率），但并没有卡顿\n `显卡绘制一帧时间 > 显示器刷新一帧时间 ? 显示器刷新(显卡等待) : 显示器显示上一帧，等待显卡绘制完成(屏幕卡顿);`\n- 解决方法：用**三重缓冲**代替垂直同步\n 三重缓冲：在双缓冲的基础上加了一个缓冲\n 在等待垂直同步时，来回交替渲染两个离屏的缓冲区\n 垂直同步发生时，屏幕缓冲区和最近渲染完成的离屏缓冲区交换，实现充分利用硬件性能的目的\n\n\n\n\n\n\n\n# 三、测试 GPU 硬件信息\n\n## 1. NV Shader 扩展功能\n\n[NV shader thread group](https://www.opengl.org/registry/specs/NV/shader_thread_group.txt) 提供了 OpenGL 的扩展，可以查询 GPU 线程、Core、SM、Warp 等硬件相关的属性（需要支持 GLVersion 4.3+ 的硬件）\n\n```c\n// 开启扩展\n#extension GL_NV_shader_thread_group : require (or enable)\n\nWARP_SIZE_NV\t// 单个线程束的线程数量\nWARPS_PER_SM_NV\t// 单个SM的线程束数量\nSM_COUNT_NV\t\t// SM数量\n\nuniform uint gl_WarpSizeNV;\t// 单个线程束的线程数量\nuniform uint gl_WarpsPerSMNV;\t// 单个SM的线程束数量\nuniform uint gl_SMCountNV;\t\t// SM数量\n\nin uint gl_WarpIDNV;\t\t// 当前线程束id\nin uint gl_SMIDNV;\t\t\t// 当前线程束所在的SM id，取值[0, gl_SMCountNV-1]\nin uint gl_ThreadInWarpNV;\t// 当前线程id，取值[0, gl_WarpSizeNV-1]\n\nin uint gl_ThreadEqMaskNV;\t// 是否等于当前线程id的位域掩码。\nin uint gl_ThreadGeMaskNV;\t// 是否大于等于当前线程id的位域掩码。\nin uint gl_ThreadGtMaskNV;\t// 是否大于当前线程id的位域掩码。\nin uint gl_ThreadLeMaskNV;\t// 是否小于等于当前线程id的位域掩码。\nin uint gl_ThreadLtMaskNV;\t// 是否小于当前线程id的位域掩码。\n\nin bool gl_HelperThreadNV;\t// 当前线程是否协助型线程(Draw quad 时，不在当前图元上的像素所在的线程)\n/**\n The variable gl_HelperThreadNV specifies if the current thread is a helper thread. In implementations supporting this extension, fragment shader invocations may be arranged in SIMD thread groups of 2x2 fragments called \"quad\". When a fragment shader instruction is executed on a quad, it's possible that some fragments within the quad will execute the instruction even if they are not covered by the primitive. Those threads are called helper threads. Their outputs will be discarded and they will not execute global store functions, but the intermediate values they compute can still be used by thread group sharing functions or by fragment derivative functions like dFdx and dFdy.\n*/\n```\n\n\n\n## 2. Sample Code\n\n```C\n// VS\n#version 430 core\nlayout (location = 0) in vec3 aPos;\n\nvoid main() {\n\tgl_Position = vec4(aPos, 1.0f);\n}\n\n// FS\n#version 430 core\n#extension GL_NV_shader_thread_group : require\n\nuniform uint gl_WarpSizeNV;\t// 单个线程束的线程数量\nuniform uint gl_WarpsPerSMNV;\t// 单个SM的线程束数量\nuniform uint gl_SMCountNV;\t\t// SM数量\n\nin uint gl_WarpIDNV;\t\t// 当前线程束id\nin uint gl_SMIDNV;\t\t\t// 当前线程所在的SM id，取值[0, gl_SMCountNV-1]\nin uint gl_ThreadInWarpNV;\t// 当前线程id，取值[0, gl_WarpSizeNV-1]\n\nout vec4 FragColor;\n\nvoid main() {\n\t// SM id\n\tfloat lightness0 = gl_SMIDNV / gl_SMCountNV;\n // warp id\n float lightness1 = gl_WarpIDNV / gl_WarpsPerSMNV;\n // thread id\n\tfloat lightness2 = gl_ThreadInWarpNV / gl_WarpSizeNV;\n \n\tFragColor = vec4(lightness0);\n}\n```\n\n\n\n**SM id 的结果 lightness0 分析：**\n\n1. 通过计算画面色阶总数得出 SM 的总数\n2. 通过单个三角面内重复的像素块个数推算每个 SM 内的核心数\n3. 不同三角形的接缝处出现断层，说明同一个像素块如果分属不同的三角形，就会分配到不同的 SM 进行处理\n 由此推断，**相同面积的区域，如果所属的三角形越多，就会导致分配给 SM 的次数越多，消耗的渲染性能也越多**\n\n\n\n\n\n\n\n# 四、GPU 硬件渲染模式\n\n## 1. IMR\n\n **Immediate Mode Rendering 立即渲染模式**：PC 端\n\n\n\n- 优点：顶点着色器和其它几何体相关着色器的输出数据能存储在 GPU 上（FIFO 缓冲区），直到管道中的下一阶段准备使用数据\n\n- 缺点：由于根据图元划分绘制批次，GPU 对整个帧缓冲进行随机访问，帧缓冲只能存储在外部 DRAM 上，导致高分辨率时内存**带宽负载高**\n\n- 优化：降带宽，将最近访问的帧缓冲存储排布在靠近 GPU 的位置来提高内存命中率\n \n- 方法：**优先根据图元来划分绘制批次**\n \n \n \n ```python\n # 每个顶点几何图形画完后直接做像素颜色，此时像素颜色不确定，需要多次读写 framebuffer（深度值的不同）\n for draw in renderPass:\n for primitive in draw:\n for vertex in primitive:\n execute_vertex_shader(vertex)\n \n if primitive not culled:\n for fragment in primitive:\n execute_fragment_shader(fragment)\n ```\n \n\n\n\n## 2. TB[D]R\n\n**Tile Based [Deferred] Rendering 基于切片的[延迟]渲染**：移动端\n\n\n\n- 优点：\n 可以将整个颜色、深度和模板的工作集存储在快速的 On-chip RAM 上（GPU 直连，不用带宽） \n 深度测试和混合透明像素所需帧缓冲数据也存储在 GPU 内部，通过提高缓存命中来降低了带宽消耗\n\n- 缺点：\n GPU 必须将每个顶点的变化数据和 Tile 的中间状态存储到主内存中，着色阶段随后读取这些数据\n 通过**延迟一帧**的方式降低了带宽\n\n- 方法：**优先根据帧缓冲来划分绘制批次**，将帧缓冲切分为几个固定大小的 Tile，分别渲染每个 Tile 上的像素\n \n \n \n ```python\n # Pass 1. 将所有几何图元属性处理后，逐个划分到对应的 Tile 中\n for draw in renderPass:\n for primitive in draw:\n for vertex in primitive:\n execute_vertex_shader(vertex)\n if primitive not culled:\n append_tile_list(primitive)\n \n # Pass 2. 根据当前 Tile 的图元属性绘制当前 Tile 所包含的所有像素\n for tile in renderPass:\n for primitive in tile:\n for fragment in primitive:\n execute_fragment_shader(fragment)\n ```\n \n\n\n\n\n\n# 五、GPU 硬件新特性\n\n## 1. Pixel Local Storage\n\n支持平台：OpenGL ES、Metal、Vulkan、D3D\n\n**Pixel Local Storage（PLS）**是一种数据存取方式，用 PLS 声明的数据将保存在 GPU 的 Tile buffer 上\n应用：**延迟着色**所需的 **GBuffer** 数据一直处于 PLS 之中，最好解析后返回最终颜色，而**不需要将 GBuffer 写回系统显存**\n\n```glsl\n// 1. 光照累积\n__pixel_localEXT FragData // 可读写数据\n{\n layout(rgba8) highp vec4 Color;\n layout(rg16f) highp vec2 NormalXY;\n layout(rg16f) highp vec2 NormalZ_LightingB;\n layout(rg16f) highp vec2 LightingRG;\n} gbuf;\n\nvoid main() {\n vec3 Lighting = CalcLighting(gbuf.NormalXY, gbuf.NormalZ_LightingB.x);\n gbuf.LightingRG += Lighting.xy;\n gbuf.NormalZ_LightingB.y += Lighting.z;\n}\n\n// 2. 最终着色\n// __pixel_local_outEXT 只读数据\n__pixel_local_inEXT FragData // 只读数据\n{\n layout(rgba8) highp vec4 Color;\n layout(rg16f) highp vec2 NormalXY;\n layout(rg16f) highp vec2 NormalZ_LightingB;\n layout(rg16f) highp vec2 LightingRG;\n} gbuf;\n\nout highp vec4 FragColor;\n\nvoid main() {\n FragColor = resolve(gbuf.Color, gbuf.LightingRG, gbuf.NormalZ_LightingB.y);\n}\n```\n\n\n\n## 2. Subpass\n\n支持平台：Metal、Vulkan、D3D\n\nSubPass 与 Pixel Local Storage 类似也是存储数据到 GPU 的 Tile buffer 上，借鉴了 TBDR 的延迟一帧的 1 Pass 拆成 图元处理 Pass 和 着色 Pass 这样两个 Subpass 的想法\n\n\n\n限制：\n\n- 所有 Subpass 必须在同一个 Render Pass 中（不能是上一个）\n- 无法在超过 GPU Tile buffer 范围外进行采样\n\n```c\n// 读\n// LOAD_OP_LOAD：从全局内存加载 Attachment 到 Tile\n// LOAD_OP_CLEAR：清理Tile缓冲区的数据。\n// LOAD_OP_DONT_CARE：不对 Tile 缓冲区的数据做任何操作，通常用于 Tile 内的数据会被全部重新，效率高于 LOAD_OP_CLEAR\n\n// 写\n// STORE_OP_STORE：将 Tile 内的数据存储到全局内存\n// STORE_OP_DONT_CARE：不对 Tile 缓冲区的数据做任何存储操作\n\n// 1. Attachment\nVkAttachmentDescription colorAttachment = {};\ncolorAttachment.format = VK_FORMAT_B8G8R8A8_SRGB;\ncolorAttachment.samples = VK_SAMPLE_COUNT_1_BIT;\n// 标明 loadOp 为 DONT_CARE\ncolorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;\n// 标明 storeOp 为 DONT_CARE\ncolorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;\n\n// 2. 为了让 Attachment 存储到 Tile 内，必须使用标记 TRANSIENT_ATTACHMENT 和 LAZILY_ALLOCATED\nVkImageCreateInfo imageInfo{VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO};\nimageInfo.flags\t\t= flags;\nimageInfo.imageType\t= type;\nimageInfo.format\t= format;\nimageInfo.extent\t= extent;\nimageInfo.samples\t= sampleCount;\n// Image 使用 TRANSIENT_ATTACHMENT 的标记\nimageInfo.usage\t\t= VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;\n\nVmaAllocation memory;\nVmaAllocationCreateInfo memoryInfo{};\nmemoryInfo.usage\t\t = memoryUsage;\n// Image 所在的内存使用 LAZILY_ALLOCATED 的标记\nmemoryInfo.preferredFlags = VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT;\n\n// 创建 Image\nauto result = vmaCreateImage(device.get_memory_allocator(), &imageInfo, memoryInfo, &handle, &memory, nullptr);\n```\n\n\n\n\n\n# 六、常见问题\n\n## 1. PCIe BindWidth\n\n显存的带宽比内存的大很多（显存的位宽大）\n\n- **内存** 和 **显存** 之间的 PCIe 总线带宽过小是 CPU 和 GPU 交互的瓶颈\n- 在移动端，由于其[耦合式的物理架构](#gpu)，带宽是一种多设备（CPU、GPU、AUDIO 等）共享的资源，而且**处理器通过带宽对存储的访问很耗电**\n- OpenGL 的**显示列表**，将一组绘制指令放到 GPU 上，CPU 只要发一条 \"执行这个显示列表\" 这些指令就执行，而不必每次渲染都发送大量指令到 GPU，从而节约 PCIe 带宽\n\n\n\n移动设备的特点：不同于 PC 端的 CPU 和 GPU 纯粹地追求计算性能，移动端在尺寸、能耗、硬件性能等诸多方面都存在显著的差异\n\n1. 性能（**P**erformance）：移动设备的各类元件（CPU、带宽、内存、GPU等）的性能都只是PC设备的数十分之一\n2. 能耗（**P**ower）：为了满足足够长的续航和散热限制，必须严格控制移动设备的整机功率\n PC 设备通常可以安装散热风扇、甚至水冷系统，而移动设备不具备这些主动散热方式，只能靠热传导散热\n 如果散热不当，CPU 和 GPU 都会主动降频，以非常有限的性能运行，以免设备元器件因过热而损毁\n3. 面积（**A**rea）：移动端的便携性就要求整机只能限制在非常小的体积之内\n\n\n\n## 2. Pipeline Barrier\n\nVulkan、Metal、DX12 等现代图形 API 可以精确指定渲染管线屏障 Barrier 的等待阶段\n避免 TBDR 这种 VS 和 FS 分两个 Pass 等待期间造成的 GPU 流水线并发率低，提高 Shader 在 GPU 运行的并发效果\n\n\n\n\n\n## 3. GPU 访问内存\n\n由于 TBDR 的 Tile GPU 缓存拆分，GPU 在访问内存时，多组 ALU 计算单元核需要串行访问\n\n\n\n\n\n\n\n# Reference\n\n1. [NV extensions](https://www.khronos.org/registry/OpenGL/extensions/NV/)\n2. [GDC Vault](https://gdcvault.com/browse/?categories=PgTaVr)\n3. [Siggraph Conference Content](https://www.siggraph.org/learn/conference-content/)\n4. [Rendering pipeline: The hardware side](https://slideplayer.com/slide/11059244/)\n4. [Introduction to GPU Architecture](http://haifux.org/lectures/267/Introduction-to-GPUs.pdf)\n4. [An Introduction to Modern GPU Architecture](http://download.nvidia.com/developer/cuda/seminar/TDCI_Arch.pdf)\n4. [Revisting Co-Processing for Hash Joins on the Coupled CPU-GPU Architecture](https://www.slideshare.net/mohamedragabslideshare/p12-29046493)\n4. [Understanding GPU caches](https://www.rastergrid.com/blog/gpu-tech/2021/01/understanding-gpu-caches/)\n8. [Transitioning from OpenGL to Vulkan](https://developer.nvidia.com/transitioning-opengl-vulkan)\n9. [Next Generation OpenGL Becomes Vulkan: Additional Details Released](https://www.anandtech.com/show/9038/next-generation-opengl-becomes-vulkan-additional-details-released)\n10. [Bringing Fortnite to Mobile with Vulkan and OpenGL ES](https://www.khronos.org/assets/uploads/developers/library/2019-gdc/Vulkan-Bringing-Fortnite-to-Mobile-Samsung-GDC-Mar19.pdf)\n5. [Graphics Processing Unit(GPU) Memory Hierarchy](http://meseec.ce.rit.edu/551-projects/spring2015/3-2.pdf)[Tile-Based Rendering](https://developer.arm.com/solutions/graphics-and-gaming/developer-guides/learn-the-basics/tile-based-rendering)\n6. [Understanding Render Passes](https://developer.arm.com/solutions/graphics-and-gaming/developer-guides/learn-the-basics/understanding-render-passes)\n6. [Asynchronous Shaders](http://developer.amd.com/wordpress/media/2012/10/Asynchronous-Shaders-White-Paper-FINAL.pdf)\n7. [GameDev Best Practices](https://developer.samsung.com/galaxy-gamedev/best-practice.html)\n8. [Accelerating Mobile XR](https://community.arm.com/cfs-file/__key/communityserver-blogs-components-weblogfiles/00-00-00-20-66/siggraph_2D00_2018_2D00_mmg_2D00_2_2D00_rob_2D00_xr.pdf)\n9. [Google Developer Contributes Universal Bandwidth Compression To Freedreno Driver](https://www.phoronix.com/scan.php?page=news_item&px=Freedreno-UBWC-A6XX)\n10. [Using pipeline barriers efficiently](https://github.com/KhronosGroup/Vulkan-Samples/blob/master/samples/performance/pipeline_barriers/pipeline_barriers_tutorial.md#the-sample)\n11. [Graphics Shaders - Theory and Practice 2nd Edition](http://cs.uns.edu.ar/cg/clasespdf/GraphicShaders.pdf)\n11. [Unreal Engine 4: Mobile Graphics on ARM CPU and GPU Architecture](https://armkeil.blob.core.windows.net/developer/Files/pdf/graphics-and-multimedia/Unreal Engine 4 Mobile Graphics on ARM CPU and GPU Architecture.pdf)\n12. [渲染优化-从GPU的结构谈起](https://zhuanlan.zhihu.com/p/58694744)\n12. [Render Graph 与现代图形 API](https://zhuanlan.zhihu.com/p/425830762)\n7. [计算机那些事(8)——图形图像渲染原理](http://chuquan.me/2018/08/26/graphics-rending-principle-gpu/)\n7. [移动游戏性能优化通用技法](https://www.cnblogs.com/timlly/p/10463467.html)\n7. [写实大世界游戏渲染技术详解 GPU 优化](https://mp.weixin.qq.com/s/T1t7dQwmxoUfuz1ik2USVg)\n7. [剖析虚幻渲染体系（12）- 移动端专题Part 2（GPU架构和机制）](https://www.cnblogs.com/timlly/p/15546797.html)\n\n"
},
{
"path": "ComputerGraphics(OpenGL)/EXT3_Platform.md",
"content": "# 零、代码 Debug\n\n> 关于性能的衡量 帧率/单帧时间，**建议采用单帧时间**\n>\n> 由于 帧率 = 60 / 单帧时间，他们之间的关系不是线性的，例如在减少同样时间消耗的情况下：\n> 低帧率区间进步缓慢，每秒 10fps 下，帧时间减少 2ms，帧率提高到 10.2fps\n> 高帧率区间进步明显，每秒 25fps 下，帧时间减少 2ms，帧率提高到 26.3fps\n\n\n\n第三方跨平台框架\n\n- [Flutter外接纹理](https://zhuanlan.zhihu.com/p/42566807)\n\n\n\n# 一、Android 平台\n\n>图片有不清晰的地方，可以点开连接看大图\n\n## 1. 数据的封装\n\n### 1.1 Surface\n内存中的一段绘图缓冲区，是对 framebuffer 的 Java 封装对象\n\n\n\n### 1.2 SurfaceTexture\n内存中的一段绘图缓冲区，对 EGL texture 的 Java 封装对象\n\n数据源：android.hardware.camera2, MediaCodec, MediaPlayer 和 Allocation 这些类的目标视频数据输出对象\n\n限制：API 11 存在，Android 3.0 及其后才能使用\n\n特点：可以接收一个 EGL texture 的纹理 ID 来产生，可以做到**离线渲染**\n\n关键方法：\n\n- updateTexImage（从内容流中获取当前帧，使得内容流中的一些帧可以跳过）\n\n- 通过 调用 getTransformMatrix 获取纹理的旋转情况\n\n\n\n\n\nSurfaceTexture 使用流程\n\n\n\n\n\n## 2. 数据的展示和刷新\n\n### 2.1 SurfaceView\n\n父类：View\n\n限制：API 1 存在\n\n回调方法运行线程：主线程\n\n优点：有自己的 Surface 来刷新，可以做到**局部刷新，独立线程刷新数据**\n\n缺点：不能进行 Transition，Rotation，Scale 等变换，这导致 SurfaceView 在由于刷新不受主线程控制，**滑动时可能有黑边**\n\n关键方法：getHolder（获取 SurfaceHolder ，SurfaceHolder 持有 Surface 数据对象）\n\n\n\n### 2.2 GLSurfaceView\n\n父类：SurfaceView\n\n限制：API 3 存在，Android 1.5 及其后才能使用\n\n关键方法：\n\n\n\n\n\n### 2.3 TextureView\n\n父类：View\n\n限制：API 14 存在，Android 4.0 及其后才能使用，只能针对用于硬件加速（没有 GPU 就无法使用）\n\n回调方法运行线程：主线程（在Android 5.0 引入渲染线程后，它是在渲染线程中做的）\n\n特点：没有自己的 Surface 来刷新，使用所在的 window 来**全局刷新**，可以进行 Transition，Rotation，Scale 等变换，**滑动时没有黑边**\n\n关键方法：\n\n- getSurfaceTexture（可能返回 null）\n\n- setSurfaceTextureListener\n\n ```java\n public DrawTextureView(Context context, AttributeSet attrs, int defStyleAttr) {\n super(context, attrs, defStyleAttr);\n this.setSurfaceTextureListener(this);\n }\n \n @Override\n public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {\n mSurface = new Surface(surface);\n }\n \n @Override\n public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {}\n \n @Override\n public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) { \n return true;\n }\n \n @Override\n public void onSurfaceTextureUpdated(SurfaceTexture surface) {}\n ```\n ![](\"./images/textureView.jpeg\")
\n \n \n\n### 2.4 Android 5.0 引入渲染线程\n\n\n\n\n\n## 3. EGL 环境配置\n\n> 如果 OpenGL 是打印机，EGL 就是纸。EGL：作为 OpenGL ES 和本地窗口的桥梁，不同平台的 EGL 实现方式不一样\n\n\n### 3.1 渲染同步问题\n\n\n本地环境和客户端环境\n\n- 本地窗口环境：Windows、X\n- 客户端环境：3D 渲染器 OpenGL、2D 矢量图形渲染器 [OpenVG](https://baike.baidu.com/item/OpenVG/7922699?fr=aladdin)\n\n\n\n同一个 surface 上可能 **同时异步** 执行了 本地窗口环境 和 客户端环境 的命令\n\n- 本地环境等待客户端环境渲染完成，效果同 glFinish 或 vgFinish 一致\n [EGLBoolean eglWaitClient(void);](https://www.khronos.org/registry/EGL/sdk/docs/man/html/eglWaitClient.xhtml)\n- 客户端环境等待本地环境渲染完成\n [EGLBoolean eglWaitNative(EGLint engine);](https://www.khronos.org/registry/EGL/sdk/docs/man/html/eglWaitNative.xhtml)\n\n\n\n### 3.2 获取 EGL 版本信息\n\n1. [EGLBoolean eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor);](https://www.khronos.org/registry/EGL/sdk/docs/man/html/eglInitialize.xhtml)\n 本质是初始化函数，但也能通过返回 major，minor 来获取当前 display 硬件设备支持的 OpenGL ES 版本号\n2. [const char* eglQueryString(EGLDisplay dpy, EGLint name);](https://www.khronos.org/registry/EGL/sdk/docs/man/html/eglQueryString.xhtml)\n 查询当前 display 硬件设备有哪些 EGL 的扩展支持，**调用前必须先通过 eglInitialize 初始化 EGL**\n\n\n\n### 3.3 EGL 的 Context 和 Surface\n\nEGL 主要作用是将渲染绘制到本地窗口上\n\nEGL 可以销毁本地资源（各种 surface 类型）\n只有一个方法，[EGLBoolean eglDestroySurface(EGLDisplay display, EGLSurface surface);](https://www.khronos.org/registry/EGL/sdk/docs/man/html/eglDestroySurface.xhtml)\n\nEGL 可以创建本地环境的资源（各种 surface 类型）格式有\n\n1. pixel buffer（存储在显存上）\n OpenGL API 方面，[EGLSurface eglCreatePbufferSurface(...)](https://www.khronos.org/registry/EGL/sdk/docs/man/html/eglCreatePbufferSurface.xhtml)\n OpenVG API 方面，[EGLSurface eglCreatePbufferFromClientBuffer(...)](https://www.khronos.org/registry/EGL/sdk/docs/man/html/eglCreatePbufferFromClientBuffer.xhtml)\n2. frame buffer（存储在显存上）\n 本地环境 API 创建的 window 内的 surface，[EGLSurface eglCreateWindowSurface(...)](https://www.khronos.org/registry/EGL/sdk/docs/man/html/eglCreateWindowSurface.xhtml)\n \n3. 本地环境 API 创建的 [pixmap（常用做本地图像的内部存储）](https://franz.com/support/documentation/current/doc/cg/cg-pixmaps.htm)，[EGLSurface eglCreatePixmapSurface(...);](https://www.khronos.org/registry/EGL/sdk/docs/man/html/eglCreatePixmapSurface.xhtml)\n\tPixmap：将图像以像素颜色数组的结构来存储的对象\n\tBitmap：用 1 bit 来存储 1 个像素颜色的 Pixmap\n\n\n\n**EGLContext 上下文创建步骤**\n\n```c\n#include \n#include \n#include \n#include \n\ntypedef ... NativeWindowType;\nextern NativeWindowType createNativeWindow(void);\n\n// 虽然是一维数组，但还是要采用 id, value, id, value ... 的存储方式\nconst EGLint attribute_list[] =\n{\n EGL_RENDERABLE_TYPE, EGL_OPENGL_ES3_BIT_KHR,\n \t//EGL_WINDOW_BIT EGL_PBUFFER_BIT we will create a pixelbuffer surface\n EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,\n EGL_RED_SIZE, \t8,\n EGL_GREEN_SIZE, \t8,\n EGL_BLUE_SIZE, 8,\n EGL_ALPHA_SIZE, 8, // if you need the alpha channel\n EGL_DEPTH_SIZE, 8, // if you need the depth buffer\n EGL_STENCIL_SIZE, 8,\n EGL_NONE\n};\n\n// EGL context attributes\nconst EGLint ctxAttr[] = {\n EGL_CONTEXT_CLIENT_VERSION, 2,\n EGL_NONE\n};\n\nvoid createGLESEnv()\n{\n EGLint num_config;\n EGLint numConfigs;\n EGLint eglMajVers;\n EGLint eglMinVers;\n \n EGLConfig config;\n EGLDisplay m_eglDisplay;\t// 关联系统物理屏幕，表示显示设备句柄\n EGLContext m_eglContext;\n EGLSurface m_eglSurface; // EGLSurface 和 Java 的 Surface 没有关系，是两个独立的对象\n NativeWindowType native_window;\n\n // 1. get an EGL display connection\n m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);\n if(EGL_NO_DISPLAY == m_eglDisplay) {\n Log.e(\"ERROR: get an EGL display connection\");\n }\n\n // 2. initialize the EGL display connection\n if (!eglInitialize(m_eglDisplay, &eglMajVers, &eglMinVers)) {\n\t\t\tLog.e(\"ERROR: initialize the EGL display connection\");\n }\n\n // 3. get an appropriate EGL frame buffer configuration\n if(!eglChooseConfig(m_eglDisplay, attribute_list, &config, 1, &num_config)) {\n Log.e(\"ERROR: get an appropriate EGL frame buffer configuration\");\n }\n\n // 4. create an EGL rendering context\n m_eglContext = eglCreateContext(m_eglDisplay, config, EGL_NO_CONTEXT, ctxAttr);\t\n \tif (EGL_NO_CONTEXT == m_eglContext) {\n EGLint error = eglGetError();\n if(error == EGL_BAD_CONFIG) {\n Log.e(\"ERROR: create an EGL rendering context\");\n }\n\t\t}\n\n // 5. create a native window\n native_window = createNativeWindow();\n\n // 6. create an EGL window surface\n m_eglSurface = eglCreateWindowSurface(m_eglDisplay, config, native_window, NULL);\n\n // 7. connect the context to the surface\n if (!eglMakeCurrent(m_eglDisplay, m_eglSurface, m_eglSurface, m_eglContext)) {\n\t\t\tLog.e(\"ERROR: connect the context to the surface\");\n }\n}\n\nvoid destroyGlESEnv()\n{\n if (m_eglDisplay != EGL_NO_DISPLAY) {\n eglMakeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);\n eglDestroyContext(m_eglDisplay, m_eglContext);\n eglDestroySurface(m_eglDisplay, m_eglSurface);\n eglReleaseThread();\n eglTerminate(m_eglDisplay);\n }\n\n m_eglDisplay = EGL_NO_DISPLAY;\n m_eglSurface = EGL_NO_SURFACE;\n m_eglContext = EGL_NO_CONTEXT;\n}\n\nint main(int argc, char ** argv)\n{\n createGLESEnv();\n\n glClearColor(1.0, 1.0, 0.0, 1.0);\n glClear(GL_COLOR_BUFFER_BIT);\n glFlush();\n\n // 所有的绘制步骤在后台绘制，当绘制完成时切换前后台缓冲，确保显示的一直是绘制完成的画面\n eglSwapBuffers(m_eglDisplay, m_eglSurface);\n \n \tdestroyGlESEnv();\n\n return EXIT_SUCCESS;\n}\n```\n\n\n\n## 4. 平台问题\n\n### 4.1 TEXTURE_EXTERNAL_OES\n\n[TEXTURE_EXTERNAL_OES](https://www.khronos.org/registry/OpenGL/extensions/OES/OES_EGL_image_external.txt) 是 OpenGL ES 在 Android 上的扩展，在获取相机纹理时只有 TEXTURE_EXTERNAL_OES 类型的纹理\n\n使用扩展纹理 TEXTURE_EXTERNAL_OES 步骤\n\n1. 创建纹理时\n\n ```java\n // 注意 GLES11Ext\n GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, texId);\n \n GLES20.glTexParameterf(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR);\n GLES20.glTexParameterf(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR);\n GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GL11.GL_TEXTURE_WRAP_S, GL11.GL_CLAMP_TO_EDGE);\n GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GL11.GL_TEXTURE_WRAP_T, GL11.GL_CLAMP_TO_EDGE);\n ```\n\n2. 在 fragment shader 里要提前声明使用的扩展\n\n ```c\n #extension GL_OES_EGL_image_external : require\n uniform samplerExternalOES u_texture; // 代替 sampler2D\n void main() {}\n ```\n\n \n\n### 4.2 Java 成员变量和 C++ 指针的 JNI 层绑定\n\n绑定指针\n\n- Java 类中，声明一个为 long 的长整型类型的成员变量代表 C++ 指针的句柄\n\n- C / C++ 文件中，每次获取 jlong 的成员变量时**强制转换为指针来使用**\n\n ```c\n #include \n \n jfieldID inline getHandleField(JNIEnv *env, jobject obj)\n {\n jclass c = env->GetObjectClass(obj);\n // J is the type signature for long:\n return env->GetFieldID(c, \"nativeHandle\", \"J\");\n }\n \n template \n T *getHandle(JNIEnv *env, jobject obj)\n {\n jlong handle = env->GetLongField(obj, getHandleField(env, obj));\n return reinterpret_cast(handle);\n }\n \n template \n void setHandle(JNIEnv *env, jobject obj, T *t)\n {\n jlong handle = reinterpret_cast(t);\n env->SetLongField(obj, getHandleField(env, obj), handle);\n }\n \n // Use Example\n MyObject* ptr = new MyObject();\n setHandle(env, object， ptr)；\n ptr = getHandle(env, object);\n ```\n\n \n\n绑定智能指针\n\n- Java 类中，声明一个为 long 的长整型类型的成员变量代表 C++ 指针的句柄\n\n- C / C++ 文件中，每次获取 jlong 的成员变量时**强制转换为包含智能指针的对象的指针来使用**\n\n ```c\n template \n class SmartPointerWrapper {\n std::shared_ptr mObject;\n public:\n template \n explicit SmartPointerWrapper(ARGS... a) {\n mObject = std::make_shared(a...);\n }\n \n explicit SmartPointerWrapper (std::shared_ptr obj) {\n mObject = obj;\n }\n \n virtual ~SmartPointerWrapper() noexcept = default;\n \n void instantiate (JNIEnv *env, jobject instance) {\n setHandle(env, instance, this);\n }\n \n jlong instance() const {\n return reinterpret_cast(this);\n }\n \n std::shared_ptr get() const {\n return mObject;\n }\n \n static std::shared_ptr object(JNIEnv *env, jobject instance) {\n return get(env, instance)->get();\n }\n \n static SmartPointerWrapper *get(JNIEnv *env, jobject instance) {\n return getHandle>(env, instance);\n }\n \n static void dispose(JNIEnv *env, jobject instance) {\n auto obj = get(env,instance);\n delete obj;\n setHandle(env, instance, nullptr);\n }\n };\n \n // Use Example\n SmartPointerWrapper