OpenGL学习之帧缓冲

最新推荐文章于 2024-07-09 14:40:51 发布
最新推荐文章于 2024-07-09 14:40:51 发布
阅读量467 收藏 4
点赞数
分类专栏： OpenGL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weiyuxinyuan/article/details/85281705
版权

什么是帧缓冲呢？

我们使用了几种不同类型的屏幕缓冲：用于写入颜色值的颜色缓冲，用于写入深度信息的深度缓冲，以及允许我们基于一些条件丢弃指定片段的模板缓冲。把这几种缓冲结合起来叫做帧缓冲(Framebuffer)，它被储存于内存中。OpenGL给了我们自己定义帧缓冲的自由，我们可以选择性的定义自己的颜色缓冲、深度和模板缓冲。

帧缓冲的步骤主要有哪些呢？

//创建帧缓冲对象
GLuint fbo;
glGenFramebuffers(1,&fbo);
//绑定帧缓冲对象
glBindFramebuffer(GL_FRAMEBUFFER,fbo);
//建构一个完整的帧缓冲必须满足以下条件：
//我们必须往里面加入至少一个附件（颜色、深度、模板缓冲）。
//其中至少有一个是颜色附件。
//所有的附件都应该是已经完全做好的（已经存储在内存之中）。
//每个缓冲都应该有同样数目的样本。
//检查当前的帧缓冲对象
if(!(glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER))
return ;
//为了让所有的渲染操作对主窗口产生影响我们必须通过绑定为0来使默认帧缓冲被激活：
glBindFramebuffer(GL_FRAMEBUFFER, 0);

//最后记得删除帧缓冲对象
glDeleteFramebuffers(1, &fbo);

下面贴图代码详细一一实验不同的帧缓冲所带来的炫酷效果。只能贴出部分重要伪代码，全部代码忽略根据你自己的场景来定。
frame.h

    //帧缓冲对象
    GLuint m_FrameBuffer;
    //帧缓冲纹理DI
    GLuint m_FrmeTextureID;
    //四边形顶点数组对象
    GLuint m_quadVAO;
    //渲染屏幕纹理着色器对象
    CShader* m_screenShader;

frame.cpp

void initScene()
{
//帧缓冲初始化代码
      //创建帧缓冲对象
      glGenFramebuffers(1, &m_FrameBuffer);
      glBindFramebuffer(GL_FRAMEBUFFER, m_FrameBuffer);
      //创建帧缓冲纹理
      glGenTextures(1, &m_FrmeTextureID);
      glBindTexture(GL_TEXTURE_2D, m_FrmeTextureID);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1024, 768, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
      glBindTexture(GL_TEXTURE_2D, 0);

      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_FrmeTextureID, 0);
      // Create a renderbuffer object for depth and stencil attachment (we won't be sampling these)
      GLuint rbo;
      glGenRenderbuffers(1, &rbo);
      glBindRenderbuffer(GL_RENDERBUFFER, rbo);
      glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, 1024, 768); // Use a single renderbuffer object for both a depth AND stencil buffer.
      glBindRenderbuffer(GL_RENDERBUFFER, 0);
      glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, rbo); // Now actually attach it
                                                                                                    // Now that we actually created the framebuffer and added all attachments we want to check if it is actually complete now
      if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
          std::cout << "ERROR::FRAMEBUFFER:: Framebuffer is not complete!" << std::endl;
      glBindFramebuffer(GL_FRAMEBUFFER, 0);

//准备渲染帧缓冲纹理到四边形的数据
                                   // Positions   // TexCoords
          -1.0f,  1.0f,  0.0f, 1.0f,
          -1.0f, -1.0f,  0.0f, 0.0f,
           1.0f, -1.0f,  1.0f, 0.0f,

          -1.0f,  1.0f, 0.0f, 1.0f,
          1.0f, -1.0f,  1.0f, 0.0f,
          1.0f,  1.0f,  1.0f, 1.0f,

      };
      // Setup screen VAO
      GLuint quadVBO;
      glGenVertexArrays(1, &m_quadVAO);
      glGenBuffers(1, &quadVBO);
      glBindVertexArray(m_quadVAO);
      glBindBuffer(GL_ARRAY_BUFFER, quadVBO);
      glBufferData(GL_ARRAY_BUFFER, sizeof(quadVertices), &quadVertices, GL_STATIC_DRAW);
      glEnableVertexAttribArray(0);
      glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat), (GLvoid*)0);
      glEnableVertexAttribArray(1);
      glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat), (GLvoid*)(2 * sizeof(GLfloat)));
      glBindVertexArray(0);
      m_screenShader->loadShader("../res/shader/screen.vs", "../res/shader/screen.ps");
 }

渲染代码:

void render()
{
    glBindFramebuffer(GL_FRAMEBUFFER, m_FrameBuffer);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT/*| GL_STENCIL_BUFFER_BIT*/);
    // Clear all attached buffers        
    glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
    glEnable(GL_DEPTH_TEST);
    //此处是你的渲染场景物体的代码。此处忽略。
  	drawScene();
    glBindFramebuffer(GL_FRAMEBUFFER, 0);

     // Clear all relevant buffers
     glClearColor(1.0f, 1.0f, 1.0f, 1.0f); // Set clear color to white (not really necessery actually, since we won't be able to see behind the quad anyways)
     glClear(GL_COLOR_BUFFER_BIT);
     glDisable(GL_DEPTH_TEST); // We don't care about depth information when rendering a single quad

     m_screenShader->ProgramUse();
     m_screenShader->setShaderUniform(m_screenShader->getProgram(), "screenTexture", (GLuint)0);
     glBindVertexArray(m_quadVAO);
     glBindTexture(GL_TEXTURE_2D, m_FrmeTextureID);	// Use the color attachment texture as the texture of the quad plane
     glDrawArrays(GL_TRIANGLES, 0, 6);
     glBindVertexArray(0);
}

渲染帧缓冲纹理的着色器代码如下：
screen.vs

#version 330 core
layout (location = 0) in vec2 position;
layout (location = 1) in vec2 texCoords;

out vec2 TexCoords;

void main()
{
    gl_Position = vec4(position.x, position.y, 0.0f, 1.0f);
    TexCoords = texCoords;
}

screen.ps

#version 330 core
in vec2 TexCoords;
out vec4 color;

uniform sampler2D screenTexture;
void main()
{
    color = texture(screenTexture, TexCoords);
}

现在看到的场景就是将帧缓冲纹理渲染到了四边形上面如图所示：
在这里插入图片描述

下面可以实现分屏，将渲染到纹理发挥到极致，只可修改四边形的顶点即可。
代码如下：

      GLfloat quadVertices1[] = {   // Vertex attributes for a quad that fills the entire screen in Normalized Device Coordinates.
           // Positions   // TexCoords
          -1.0f,  1.0f,  0.0f, 1.0f,
          -1.0f, -1.0f,  0.0f, 0.0f,
          0.0f, -1.0f,  1.0f, 0.0f,

          -1.0f,  1.0f,  0.0f, 1.0f,
          0.0f, -1.0f,  1.0f, 0.0f,
          0.0f,  1.0f,  1.0f, 1.0f,

          0.0f, 1.0f,   0.0f, 1.0f,
          0.0f,-1.0f,   0.0f, 0.0f,
          1.0f,-1.0f,   1.0f, 0.0f,

          0.0f,1.0f,    0.0f,1.0f,
          1.0f,-1.0f,   1.0f,0.0f,
          1.0f,1.0f,    1.0f,1.0f
      };
别忘了在渲染四边形时修改：
     glBindVertexArray(m_quadVAO);
     glBindTexture(GL_TEXTURE_2D, m_FrmeTextureID);	// Use the color attachment texture as the texture of the quad plane
     glDrawArrays(GL_TRIANGLES, 0, 12); //改为12
     glBindVertexArray(0);

效果如下所示：
在这里插入图片描述

后期处理

接下来的实验变得简单了，只需要对片段着色器进行修改即可。
1.反相
screen.ps

#version 330 core
in vec2 TexCoords;
out vec4 color;

uniform sampler2D screenTexture;
void main()
{
   //反相
   //color = vec4(vec3(1.0 - texture(screenTexture, TexCoords)), 1.0);
 }

效果如下图：
在这里插入图片描述
2.灰度

#version 330 core
in vec2 TexCoords;
out vec4 color;

uniform sampler2D screenTexture;
void main()
{
    color = texture(screenTexture, TexCoords);
   //灰度
   float average = (color.r + color.b + color.b) / 3.0;
   color = vec4(average , average, average, 1.0);
 }

效果如下所示：
在这里插入图片描述
3.边检测
screen.ps

#version 330 core
in vec2 TexCoords;
out vec4 color;

uniform sampler2D screenTexture;
const float fuzzy = 1.0 / 300;
void main()
{
       vec2 offsets[9] = vec2[](
        vec2(-fuzzy, fuzzy),  // top-left
        vec2(0.0f,    fuzzy),  // top-center
        vec2(fuzzy,  fuzzy),  // top-right
        vec2(-fuzzy, 0.0f),    // center-left
        vec2(0.0f,    0.0f),    // center-center
        vec2(fuzzy,  0.0f),    // center-right
        vec2(-fuzzy, -fuzzy), // bottom-left
        vec2(0.0f,    -fuzzy), // bottom-center
        vec2(fuzzy,  -fuzzy)  // bottom-right
    );

    float kernel[9] = float[](
        1, 1, 1,
        1, -8,1,
        1, 1, 1
    );
    
    vec3 sampleTex[9];
    for(int i = 0; i < 9; i++)
    {
        sampleTex[i] = vec3(texture(screenTexture, TexCoords.st + offsets[i]));
    }
    vec3 col;
    for(int i = 0; i < 9; i++)
        col += sampleTex[i] * kernel[i];

    color = vec4(col, 1.0);
}

效果如下所示:
在这里插入图片描述
4.锐化

#version 330 core
in vec2 TexCoords;
out vec4 color;

uniform sampler2D screenTexture;
const float fuzzy = 1.0 / 300;
void main()
{
       vec2 offsets[9] = vec2[](
        vec2(-fuzzy, fuzzy),  // top-left
        vec2(0.0f,    fuzzy),  // top-center
        vec2(fuzzy,  fuzzy),  // top-right
        vec2(-fuzzy, 0.0f),    // center-left
        vec2(0.0f,    0.0f),    // center-center
        vec2(fuzzy,  0.0f),    // center-right
        vec2(-fuzzy, -fuzzy), // bottom-left
        vec2(0.0f,    -fuzzy), // bottom-center
        vec2(fuzzy,  -fuzzy)  // bottom-right
    );

//原则是里面的每个值相加要必须等于1
    float kernel[9] = float[](
        -1, -1, -1,
        -1,  9, -1,
        -1, -1, -1
    );
    
    vec3 sampleTex[9];
    for(int i = 0; i < 9; i++)
    {
        sampleTex[i] = vec3(texture(screenTexture, TexCoords.st + offsets[i]));
    }
    vec3 col;
    for(int i = 0; i < 9; i++)
        col += sampleTex[i] * kernel[i];

    color = vec4(col, 1.0);
}

如图所示：
在这里插入图片描述
5.模糊
创建模糊(Blur)效果的kernel定义如下：
是由一个3x3矩阵定义。所有数值加起来的总和为16,简单返回结合起来的采样颜色是非常亮的,所以我们必须将kernel的每个值除以16。
screen.ps

#version 330 core
in vec2 TexCoords;
out vec4 color;

uniform sampler2D screenTexture;
const float fuzzy = 1.0 / 300;
void main()
{
       vec2 offsets[9] = vec2[](
        vec2(-fuzzy, fuzzy),  // top-left
        vec2(0.0f,    fuzzy),  // top-center
        vec2(fuzzy,  fuzzy),  // top-right
        vec2(-fuzzy, 0.0f),    // center-left
        vec2(0.0f,    0.0f),    // center-center
        vec2(fuzzy,  0.0f),    // center-right
        vec2(-fuzzy, -fuzzy), // bottom-left
        vec2(0.0f,    -fuzzy), // bottom-center
        vec2(fuzzy,  -fuzzy)  // bottom-right
    );

	float kernel[9] = float[](
    1.0 / 16, 2.0 / 16, 1.0 / 16,
    2.0 / 16, 4.0 / 16, 2.0 / 16,
    1.0 / 16, 2.0 / 16, 1.0 / 16  
);
    
    vec3 sampleTex[9];
    for(int i = 0; i < 9; i++)
    {
        sampleTex[i] = vec3(texture(screenTexture, TexCoords.st + offsets[i]));
    }
    vec3 col;
    for(int i = 0; i < 9; i++)
        col += sampleTex[i] * kernel[i];

    color = vec4(col, 1.0);
}

效果如下所示：
在这里插入图片描述
最后呢，我想做一个由模糊逐渐过渡到清晰的效果着色器代码如下：

#version 330 core
in vec2 TexCoords;
out vec4 color;

uniform sampler2D screenTexture;
uniform float fuzzy; //定义模糊值
void main()
{
       vec2 offsets[9] = vec2[](
        vec2(-fuzzy, fuzzy),  // top-left
        vec2(0.0f,    fuzzy),  // top-center
        vec2(fuzzy,  fuzzy),  // top-right
        vec2(-fuzzy, 0.0f),    // center-left
        vec2(0.0f,    0.0f),    // center-center
        vec2(fuzzy,  0.0f),    // center-right
        vec2(-fuzzy, -fuzzy), // bottom-left
        vec2(0.0f,    -fuzzy), // bottom-center
        vec2(fuzzy,  -fuzzy)  // bottom-right
    );

	float kernel[9] = float[](
    1.0 / 16, 2.0 / 16, 1.0 / 16,
    2.0 / 16, 4.0 / 16, 2.0 / 16,
    1.0 / 16, 2.0 / 16, 1.0 / 16  
);

    vec3 sampleTex[9];
    for(int i = 0; i < 9; i++)
    {
        sampleTex[i] = vec3(texture(screenTexture, TexCoords.st + offsets[i]));
    }
    vec3 col;
    for(int i = 0; i < 9; i++)
        col += sampleTex[i] * kernel[i];

    color = vec4(col, 1.0);
}

frame.cpp

     m_screenShader->ProgramUse();
     m_screenShader->setShaderUniform(m_screenShader->getProgram(), "screenTexture", (GLuint)0);
     //模糊值计算
     static float fuzzy = 0;
     fuzzy +=  2 * frameTime * 10.0;
     m_screenShader->setShaderUniform(m_screenShader->getProgram(), "fuzzy", 1 / fuzzy);
     if (fuzzy > 1500.0f)
     {
         fuzzy = 0.0f;
     }
     glBindVertexArray(m_quadVAO);
     glBindTexture(GL_TEXTURE_2D, m_FrmeTextureID);	// Use the color attachment texture as the texture of the quad plane
     glDrawArrays(GL_TRIANGLES, 0, 6);
     glBindVertexArray(0);

效果如下：
在这里插入图片描述
好了，收工。

一只独立特行的猪
关注
专栏目录
零基础学习OpenGL（七）--帧缓冲、后处理
jfy307596479的博客
11-29 1083
       用于写入颜色值的颜色缓冲、用于写入深度信息的深度缓冲和允许我们根据一些条件丢弃特定片段的模板缓冲。这些缓冲结合起来叫做帧缓冲(Framebuffer)，它被储存在内存中。OpenGL允许我们定义我们自己的帧缓冲，也就是说我们能够定义我们自己的颜色缓冲，甚至是深度缓冲和模板缓冲。        我们目前所做的所有操作都是在默认帧缓冲的渲染缓冲上进行的。默认的帧缓冲是在你创建窗口的时候...
OpenGL学习笔记 帧缓冲
linsang233的博客
07-13 334
帧缓存 到目前为止，我们已经使用了很多屏幕缓冲了：用于写入颜色值的颜色缓冲、用于写入深度信息的深度缓冲和允许我们根据一些条件丢弃特定片段的模板缓冲。***这些缓冲结合起来叫做帧缓冲(Framebuffer)***，它被储存在内存中。OpenGL允许我们定义我们自己的帧缓冲，也就是说我们能够定义我们自己的颜色缓冲，甚至是深度缓冲和模板缓冲。 帧缓存实现效果： 啊这，好像没能体现什么特别的。 那我们再在代码中加入 //线框模式绘制 glPolygonMode(GL_FRONT_AND_BACK, GL_L
OpenGL帧缓冲
xiao_ran_give_up的博客
07-03 336
深夜博客记录一下。帧缓冲： 用于写入颜色值的颜色缓冲、用于写入深度信息的深度缓冲和允许我们根据一些条件丢弃特定片段的模板缓冲等组合起来叫帧缓冲。OpenGL允许我们定义我们自己的帧缓冲，也就是说我们能够定义我们自己的颜色缓冲，甚至是深度缓冲和模板缓冲。帧缓冲的四个条件：附件是一个内存位置，它能够作为帧缓冲的一个缓冲。当创建一个附件的时候我们有两个选项：纹理或渲染缓冲对象(Renderbuffer Object)。...
frame buffer ——帧缓冲区
最新发布
l22221的博客
07-09 1043
帧缓冲区就像是屏幕的“草稿纸”，图形处理器（GPU）在上面绘制图像，然后将结果呈现到屏幕上。在嵌入式系统中，例如Linux系统下，可以通过访问特定的设备节点（如/dev/fb0）来直接读写帧缓冲区，从而实现图形输出或进行底层的图形编程允许上层应用程序在图形模式下直接对显示缓冲区进行读写操作对于应用层，通过操作/dev/fb*，通过ioctl来用各种命令控制fb/usr/include/linux/fb.h 中查看。
opengl帧缓冲
copymaster
01-04 366
缓冲区 用于写入颜色值的颜色缓冲、用于写入深度信息的深度缓冲和允许我们根据一些条件丢弃特定片段的模板缓冲。这些缓冲结合起来叫做帧缓冲(Framebuffer)，它被储存在内存中。OpenGL允许我们定义我们自己的帧缓冲，也就是说我们能够定义我们自己的颜色缓冲，甚至是深度缓冲和模板缓冲。 我们目前所做的所有操作都是在默认帧缓冲的渲染缓冲上进行的。默认的帧缓冲是在你创建窗口的时候生成和配置的（GLFW...
Linux的帧缓冲设备
Linuxer_zxp的专栏
08-23 1221
<br />参见：<br />http://blog.ednchina.com/exbob/254847/message.aspx<br />Linux的帧缓冲设备 <br />帧缓冲（framebuffer）是 Linux 为显示设备提供的一个接口，把显存抽象后的一种设备，他允许上层应用程序在<br />图形模式下直接对显示缓冲区进行读写操作。这种操作是抽象的，统一的。用户不必关心物理显存的位置、换页机<br />制等等具体细节。这些都是由Framebuffer 设备驱动来完成的。帧缓冲驱动的应用广泛，在
帧缓冲
cs_hang的博客
09-18 1044
创建FrameBuffer并绑定纹理和渲染缓冲 unsigned int fbo; glGenFramebuffers(1, &fbo); glBindFramebuffer(GL_FRAMEBUFFER, fbo); unsigned int texColorBuffer; glGenTextures(1, &texColorBuffer); glBindTextur...
OpenGLES 学习之帧缓存
小薇子的博客
06-08 828
什么是帧缓冲区 帧缓冲区（framebuffer object）简称 FBO，用于写入颜色值，写入深度信息和深度缓冲和允许我们根据一些条件丢弃特定片段的模板缓冲。 图像在绘制时最终都是绘制到帧缓冲区中的，一般情况下我们都是使用的是默认FBO，也就是我们的屏幕，也就是着色器各方面绘制结果存储的逻辑对象。 使用方式 1. 创建帧缓冲区 使用glGenFramebuffers 来创建一个帧缓冲对象 unsigned int framebuffer; glGenFramebuffers(1,&framebu
OpenGL学习（三）帧缓冲
qiaozh的博客
04-08 471
之前的学习中，或者说有shader基础的同学们都知道在渲染管线内有很多屏幕缓冲，比如颜色缓冲，上节提到的深度缓冲和模板缓冲，这些缓冲结合起来就是帧缓冲（FrameBuffer），它被储存在内存当中，而OpenGL允许我们定义自己的帧缓冲。 创建帧缓冲，和创建其他对象缓冲一样，会使用glGenFramebuffers函数 unsigned int framebuffer; glGenFramebuffers(1,&framebuffer); glBindFramebuffer(GL
Cube映射 + Opengl帧缓冲
11-26
OpenGL帧缓冲与Cube映射是计算机图形学中的两个重要概念，尤其在3D渲染和游戏开发中广泛应用。本文将深入探讨这两个技术，并结合 Cube Map 的使用进行详细解析。 首先，让我们来理解 Cube 映射（Cube Mapping）。...
LearnOpenGL学习笔记—高级OpenGL 05：帧缓冲
清清！的博客
09-05 1968
LearnOpenGL学习笔记—高级OpenGL 04：帧缓冲1 知识：帧缓冲2 知识：创建一个帧缓冲3 知识：纹理附件4 知识：渲染缓冲对象（RBO）附件5 知识：将图像渲染到纹理6 FBO绘制代码实现过程7 知识与实践：后期处理7.1 反相7.2 灰度7.3 卷积核7.3.1 锐化核7.3.2 模糊核7.3 边缘检测8 代码文件 本节对应官网学习内容：帧缓冲 1 知识：帧缓冲 到目前为止，我们已经使用了很多屏幕缓冲了： 用于写入颜色值的颜色缓冲、用于写入深度信息的深度缓冲和允许我们根据一些条件丢弃特定
OpenGL学习笔记一之高级OpenGL篇五 帧缓冲
飞飞飞的博客
05-06 923
转载自https://learnopengl-cn.github.io/04%20Advanced%20OpenGL/05%20Framebuffers/ 到目前为止，我们已经使用了很多屏幕缓冲了：用于写入颜色值的颜色缓冲、用于写入深度信息的深度缓冲和允许我们根据一些条件丢弃特定片段的模板缓冲。这些缓冲结合起来叫做帧缓冲(Framebuffer)，它被储存在内存中。OpenGL允许我们定义我们...
[C++] [OpenGL] 帧缓冲
qq_53530146的博客
05-02 631
代码 GLuint fbo; GLuint rbo; GLuint texture; //获取帧缓冲对象 glGenFramebuffers(1, &fbo); glBindFramebuffer(GL_FRAMEBUFFER, fbo); //获取渲染缓冲对象 glGenRenderbuffers(1, &rbo); glBindRenderbuffer(GL_RENDERBUFFER, rbo); glRenderbufferStorage(GL_RENDERBUFF
OpenGL之帧缓冲详解
ArvinFei的博客
05-17 2790
简介 OpenGlES中的物体绘制并不是直接在屏幕上进行的，而是预先在帧缓冲区内进行绘制的，每绘制完一帧再将绘制的结果交换到屏幕上，所以每次绘制新的一帧时，都要清除缓冲区中的相关数据，否则可能产生不正确的绘制。 包括三种类型的屏幕缓冲 颜色缓冲 用于存储每个片元的颜色值，每个颜色包括RGBA4个色彩通道，应用程序看到的内容就是颜色缓冲区中的内容 用于写入深度信息的深度缓冲 用于存储每个片元的深度值，是指从片元处到观察点（相机）的距离。在启用深度测试的情况下，新片元想进入帧缓冲时需要将自己的深度值与帧缓冲.
OpenGL学习脚印: 帧缓冲对象(Frame Buffer Object)
热门推荐
王定桥的专栏
09-03 1万+
写在前面 一直以来，我们在使用OpenGL渲染时，最终的目的地是默认的帧缓冲区，实际上OpenGL也允许我们创建自定义的帧缓冲区。使用自定义的帧缓冲区，可以实现镜面，离屏渲染，以及很酷的后处理效果。本节将学习帧缓存的使用，文中示例代码均可以在我的github下载。 本节内容整理自 1.OpenGL Frame Buffer Object (FBO) 2.www.learn
OpenGL 帧缓冲区
weixin_34416649的博客
12-26 94
　　帧缓冲区　　几乎每个图形程序的重要目标之一都是在屏幕上绘制图形。屏幕是由一个矩形像素数组组成的，每个像素都可以在图像的某一个点上显示一个某种颜色的微小方块。在光栅化阶段（包括纹理和雾）之后，数据就不再是像素，而是片段。每个片段都具有与像素对应的坐标数据以及颜色值和深度值。　　如果顺利通过了这些测试和操作，片段值便可以转换为像素。如果顺利通过了这些测试和操作，片段值便可以转换为像素。为了绘制这...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值