LearnOpenGL - Android OpenGL ES 3.0 使用 FBO 进行离屏渲染

于 2024-06-27 18:30:32 发布
阅读量1k 收藏 11
点赞数 20
分类专栏： 音视频 opengl 文章标签： android 音视频 OpenGL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weiwei9363/article/details/140018912
版权

系列文章目录

一、前言

利用 FBO（Framebuffer Object），我们可以实现离屏渲染。在前面的章节中，当我们调用 glDrawElements 后，手机屏幕上就会显示出绘制的图像。这意味着 OpenGL 将数据直接渲染到了手机屏幕上。通过使用 FBO，我们可以将数据渲染到纹理上，而不是直接渲染到屏幕，这个过程称为离屏渲染。

通过离屏渲染，我们可以在最终显示之前对图像进行复杂的处理。这种方法非常有用，比如在后期处理效果（如模糊、HDR、阴影等）中，或者在渲染多个场景以进行纹理贴图、环境映射等操作时。

假设你在开发一款图片处理软件，包含美颜、滤镜等功能。用户可以同时应用多种滤镜，如瘦脸、美白、长腿等，每种滤镜都通过 OpenGL Shader 进行处理和渲染。为实现这种功能，你可以设计一个图片渲染链。

一种直观的方法是为每种滤镜创建一个独立的模块，通过组合不同的模块实现多种滤镜的处理链。在处理链完成之前，我们无法将结果渲染到屏幕上。模块与模块之间的处理结果应该通过某种介质进行传递，这里使用的介质就是纹理。这也解释了我们为什么需要使用 FBO。

通过 FBO，我们可以在离屏状态下将渲染结果存储到纹理中，然后将该纹理作为输入传递给下一个滤镜模块。这样，整个处理链就可以逐步处理图像，直到应用所有滤镜后，将最终结果渲染到屏幕上。

在这里插入图片描述
本文所有代码在 FBODrawer.kt

二、FBO 简介

在这里插入图片描述
上图显示了帧缓冲区对象的结构，它提供了颜色缓冲区和深度缓冲区的替代品。如你所见，绘制操作并不是直接发生在帧缓冲区中的，而是发生在帧缓冲区所关联的对象（attachment）上。一个帧缓冲区有多个关联对象：颜色关联对象（color attachment）、深度关联对象（depth attachment）和模板关联对象（stencil attachment），分别用来替代颜色缓冲区、深度缓冲区和模板缓冲区。经过一些设置，OpenGL 就可以向帧缓冲区的关联对象中写入数据，就像写入颜色缓冲区或深度缓冲区一样。我们目前只关注颜色关联对象即可

每个关联对象又可以是两种类型的：纹理对象或渲染缓冲区对象（renderbuffer object）。当我们把纹理对象作为颜色关联对象关联到帧缓冲区对象后，OpenGL 就可以在纹理对象中绘图。渲染缓冲区对象表示一种更加通用的绘图区域，可以向其中写入多种类型的数据。

2.1 渲染缓冲对象

渲染缓冲区对象（Renderbuffer Object）是 OpenGL 和 OpenGL ES 中的一种缓冲区类型，用于离屏渲染。它提供了一种高效的方式来存储图像数据，特别适用于深度缓冲区和模板缓冲区。

渲染缓冲区对象的特点：

  1. 高效存储：

    • 渲染缓冲区对象在实现上通常比纹理对象更高效，特别是用于深度和模板数据的存储。
    • 它不需要纹理过滤、MIP 贴图等特性，因此在某些场景下可以提供更好的性能。

  2. 不可直接采样：

    • 与纹理对象不同，渲染缓冲区对象不能直接被着色器采样。
    • 这意味着你不能在着色器中直接访问渲染缓冲区对象中的数据，只能用于渲染过程。

  3. 用途广泛：

    • 渲染缓冲区对象可以用作颜色、深度或模板缓冲区。
    • 在使用 FBO 进行离屏渲染时，渲染缓冲区对象可以作为这些附件类型附加到 FBO 上。

渲染缓冲区对象的使用步骤：

  1. 创建渲染缓冲区对象：

    GLuint rbo;
glGenRenderbuffers(1, &rbo);
glBindRenderbuffer(GL_RENDERBUFFER, rbo);

  2. 分配存储：

    • 根据用途分配存储，比如深度缓冲区、颜色缓冲区等。
    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, width, height);
// 或者为颜色缓冲区分配存储
// glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, width, height);

  3. 附加到 FBO：

    • 将渲染缓冲区对象附加到 FBO 作为附件。
    glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rbo);
// 如果是颜色缓冲区
// glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbo);

纹理对象与渲染缓冲区对象的对比：

  • 纹理对象：

    • 可以在着色器中采样，用于更灵活的图像处理。
    • 适用于需要在多个渲染步骤中反复使用和处理的图像数据。

  • 渲染缓冲区对象：

    • 高效的存储和写入，但不能在着色器中采样。
    • 适用于深度缓冲区和模板缓冲区，或者不需要在着色器中采样的颜色缓冲区。

结合使用：

在实际应用中，常常将纹理对象和渲染缓冲区对象结合使用。比如：

  • 使用渲染缓冲区对象存储深度和模板数据，以获得更高的性能。
  • 使用纹理对象存储颜色数据，以便在后续渲染步骤中进行采样和处理。

例子：

假设我们在开发一个图片处理软件，通过 FBO 进行多重滤镜处理。每个滤镜模块会产生一个中间结果，这些中间结果通常存储在纹理对象中，因为它们需要被后续的滤镜模块采样和处理。然而，为了提高性能，我们可以使用渲染缓冲区对象来存储深度数据，因为这些数据通常不需要在滤镜处理中直接访问。

// 创建并绑定 FBO
GLuint fbo;
glGenFramebuffers(1, &fbo);
glBindFramebuffer(GL_FRAMEBUFFER, fbo);

// 创建并附加颜色附件（纹理对象）
GLuint colorTex;
glGenTextures(1, &colorTex);
glBindTexture(GL_TEXTURE_2D, colorTex);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, colorTex, 0);

// 创建并附加深度附件（渲染缓冲区对象）
GLuint depthRbo;
glGenRenderbuffers(1, &depthRbo);
glBindRenderbuffer(GL_RENDERBUFFER, depthRbo);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, width, height);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depthRbo);

// 检查 FBO 完整性
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
    // 处理错误
}

// 解绑 FBO 以恢复默认帧缓冲区
glBindFramebuffer(GL_FRAMEBUFFER, 0);

通过这种方式，我们可以高效地实现图像的离屏渲染和多重滤镜处理。

三、FBO 使用流程

GLES30.glGenTextures(1, fboTexIds)
GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, fboTexIds[0])
GLES30.glTexParameteri(GLES30.GL_TEXTURE_2D, GLES30.GL_TEXTURE_MIN_FILTER, GLES30.GL_LINEAR)
GLES30.glTexParameteri(GLES30.GL_TEXTURE_2D, GLES30.GL_TEXTURE_MAG_FILTER, GLES30.GL_LINEAR)
GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, GLES30.GL_NONE)

// generate fbo id and config fbo
// 创建 FBO
GLES30.glGenFramebuffers(1, fbo);
GLES30.glBindFramebuffer(GLES30.GL_FRAMEBUFFER, fbo[0])
GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, fboTexIds[0])
GLES30.glFramebufferTexture2D(GLES30.GL_FRAMEBUFFER, GLES30.GL_COLOR_ATTACHMENT0, GLES30.GL_TEXTURE_2D, fboTexIds[0], 0)
GLES30.glTexImage2D(GLES30.GL_TEXTURE_2D, 0, GLES30.GL_RGBA, imageWidth, imageHeight, 0, GLES30.GL_RGBA, GLES30.GL_UNSIGNED_BYTE, null)
GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, GLES30.GL_NONE)
GLES30.glBindFramebuffer(GLES30.GL_FRAMEBUFFER, GLES30.GL_NONE)

这段代码用于在 OpenGL ES 3.0 中创建并配置一个帧缓冲区对象（FBO），并将一个纹理对象附加到这个帧缓冲区对象上作为颜色附件，以便进行离屏渲染。下面是对每行代码的详细解释：

创建和配置纹理对象

// 生成一个纹理对象，并将其ID存储在 fboTexIds 数组中
GLES30.glGenTextures(1, fboTexIds);

// 绑定生成的纹理对象
GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, fboTexIds[0]);

// 设置纹理过滤参数，线性过滤
GLES30.glTexParameteri(GLES30.GL_TEXTURE_2D, GLES30.GL_TEXTURE_MIN_FILTER, GLES30.GL_LINEAR);
GLES30.glTexParameteri(GLES30.GL_TEXTURE_2D, GLES30.GL_TEXTURE_MAG_FILTER, GLES30.GL_LINEAR);

// 解除纹理绑定
GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, GLES30.GL_NONE);

  1. 生成纹理对象：

    • GLES30.glGenTextures(1, fboTexIds);：生成一个纹理对象，并将其ID存储在 fboTexIds 数组中。

  2. 绑定纹理对象：

    • GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, fboTexIds[0]);：将生成的纹理对象绑定到目标 GL_TEXTURE_2D。

  3. 设置纹理参数：

    • GLES30.glTexParameteri(GLES30.GL_TEXTURE_2D, GLES30.GL_TEXTURE_MIN_FILTER, GLES30.GL_LINEAR);：设置纹理的缩小过滤为线性过滤。
    • GLES30.glTexParameteri(GLES30.GL_TEXTURE_2D, GLES30.GL_TEXTURE_MAG_FILTER, GLES30.GL_LINEAR);：设置纹理的放大过滤为线性过滤。

  4. 解除纹理绑定：

    • GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, GLES30.GL_NONE);：解除当前绑定的纹理对象。

创建和配置帧缓冲区对象

// 生成一个帧缓冲区对象，并将其ID存储在 fbo 数组中
GLES30.glGenFramebuffers(1, fbo);

// 绑定生成的帧缓冲区对象
GLES30.glBindFramebuffer(GLES30.GL_FRAMEBUFFER, fbo[0]);

// 重新绑定之前创建的纹理对象
GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, fboTexIds[0]);

// 将纹理对象附加到帧缓冲区对象的颜色附件上
GLES30.glFramebufferTexture2D(GLES30.GL_FRAMEBUFFER, GLES30.GL_COLOR_ATTACHMENT0, GLES30.GL_TEXTURE_2D, fboTexIds[0], 0);

// 为纹理对象分配存储空间
GLES30.glTexImage2D(GLES30.GL_TEXTURE_2D, 0, GLES30.GL_RGBA, imageWidth, imageHeight, 0, GLES30.GL_RGBA, GLES30.GL_UNSIGNED_BYTE, null);

// 解除纹理绑定
GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, GLES30.GL_NONE);

// 解除帧缓冲区对象的绑定
GLES30.glBindFramebuffer(GLES30.GL_FRAMEBUFFER, GLES30.GL_NONE);

  1. 生成帧缓冲区对象：

    • GLES30.glGenFramebuffers(1, fbo);：生成一个帧缓冲区对象，并将其ID存储在 fbo 数组中。

  2. 绑定帧缓冲区对象：

    • GLES30.glBindFramebuffer(GLES30.GL_FRAMEBUFFER, fbo[0]);：将生成的帧缓冲区对象绑定到目标 GL_FRAMEBUFFER。

  3. 重新绑定纹理对象：

    • GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, fboTexIds[0]);：将之前创建的纹理对象重新绑定到目标 GL_TEXTURE_2D。

  4. 附加纹理对象到帧缓冲区对象：

    • GLES30.glFramebufferTexture2D(GLES30.GL_FRAMEBUFFER, GLES30.GL_COLOR_ATTACHMENT0, GLES30.GL_TEXTURE_2D, fboTexIds[0], 0);：将纹理对象作为颜色附件附加到帧缓冲区对象上。

  5. 为纹理对象分配存储空间：

    • GLES30.glTexImage2D(GLES30.GL_TEXTURE_2D, 0, GLES30.GL_RGBA, imageWidth, imageHeight, 0, GLES30.GL_RGBA, GLES30.GL_UNSIGNED_BYTE, null);：为纹理对象分配存储空间，并指定其格式和尺寸。

  6. 解除纹理绑定：

    • GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, GLES30.GL_NONE);：解除当前绑定的纹理对象。

  7. 解除帧缓冲区对象的绑定：

    • GLES30.glBindFramebuffer(GLES30.GL_FRAMEBUFFER, GLES30.GL_NONE);：解除当前绑定的帧缓冲区对象。

四、FBO 离屏渲染

为了演示 FBO 离屏渲染，我在 FBODrawer.kt 构建了两个 shader，第一个 shader 将 RGB 图片转换为灰度图，第二个 shader 则将纹理渲染到屏幕上。

companion object {
    val vertexShaderSource =
        """
        #version 300 es
        layout(location = 0) in vec3 a_posit
        layout(location = 1) in vec2 a_texco
        
        out vec2 v_texcoord;
        
        void main()
        {
            gl_Position = vec4(a_position, 1
            v_texcoord = a_texcoord;
        }
        """.trimIndent()
    val fragmentShaderSource =
        """
        #version 300 es
        precision mediump float;
        
        uniform sampler2D texture0;
        in vec2 v_texcoord;
        out vec4 fragColor;
        void main(void)
        {
            fragColor = texture(texture0, v_
        }
        """.trimIndent()
    val fboFragmentShaderSource =
        """
        #version 300 es
        precision mediump float;
        
        uniform sampler2D texture0;
        in vec2 v_texcoord;
        out vec4 fragColor;
        void main(void)
        void main(void)
		{
    		vec4 tempColor = texture(texture0, v_texcoord);
    		float gray = 0.299*tempColor.a + 0.587*tempColor.g + 0.114*tempColor.b;
    		fragColor = vec4(vec3(gray), 1.0);
		}
        """.trimIndent()
}
private val shader = Shader(
    vertexShaderSource,
    fragmentShaderSource
)
private val fboShader = Shader(
    vertexShaderSource,
    fboFragmentShaderSource
)

因此我们需要调用两次 draw 方法：

  1. 第一次，我们的 shader 输入是 rgb 图片的纹理，输出是灰度图纹理
  2. 第二次，我们的 shader 输入是灰度图纹理，然后直接绘制到纹理上
override fun draw() {
    // first, fbo off screen rendering
    GLES30.glViewport(0, 0, imageWidth, imageHeight)
    GLES30.glBindFramebuffer(GLES30.GL_FRAMEBUFFER, fbo[0])
    fboShader.use()
    fboShader.setInt("texture0", 0)
    GLES30.glBindVertexArray(vaos[0])
    GLES30.glActiveTexture(GLES30.GL_TEXTURE0)
    GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, imageTexIds[0])
    GLES30.glDrawElements(GLES30.GL_TRIANGLES, indices.size, GLES30.GL_UNSIGNED_INT, 0)
    GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, 0)
    GLES30.glBindVertexArray(0)
    GLES30.glBindFramebuffer(GLES30.GL_FRAMEBUFFER, 0)
    // second, draw texture to screen
    GLES30.glViewport(0, 0, screenWidth, screenHeight)
    shader.use()
    shader.setInt("texture0", 0)
    GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT)
    GLES30.glBindVertexArray(vaos[0])
    GLES30.glActiveTexture(GLES30.GL_TEXTURE0)
    GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, fboTexIds[0]) // 用 fbo 渲染的结果作为纹理的输入
    GLES30.glDrawElements(GLES30.GL_TRIANGLES, indices.size, GLES30.GL_UNSIGNED_INT, 0)
    GLES30.glBindVertexArray(0)
}

这段代码展示了如何使用帧缓冲区对象（FBO）进行离屏渲染，然后将离屏渲染的结果绘制到屏幕上。具体分为两个步骤：第一步是将场景渲染到 FBO，第二步是将 FBO 的内容作为纹理绘制到屏幕上。

第一步：离屏渲染到 FBO

// 设置视口为 FBO 的尺寸
GLES30.glViewport(0, 0, imageWidth, imageHeight);

// 绑定 FBO
GLES30.glBindFramebuffer(GLES30.GL_FRAMEBUFFER, fbo[0]);

// 使用离屏渲染的着色器程序
fboShader.use();

// 设置着色器程序中纹理单元的位置
fboShader.setInt("texture0", 0);

// 绑定 VAO
GLES30.glBindVertexArray(vaos[0]);

// 激活纹理单元并绑定需要渲染的纹理
GLES30.glActiveTexture(GLES30.GL_TEXTURE0);
GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, imageTexIds[0]);

// 绘制元素
GLES30.glDrawElements(GLES30.GL_TRIANGLES, indices.size, GLES30.GL_UNSIGNED_INT, 0);

// 解除纹理绑定
GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, 0);

// 解除 VAO 绑定
GLES30.glBindVertexArray(0);

// 解除 FBO 绑定，恢复默认帧缓冲区
GLES30.glBindFramebuffer(GLES30.GL_FRAMEBUFFER, 0);
  1. 设置视口：GLES30.glViewport(0, 0, imageWidth, imageHeight) 设置渲染区域为 FBO 的尺寸。
  2. 绑定 FBO：GLES30.glBindFramebuffer(GLES30.GL_FRAMEBUFFER, fbo[0]) 绑定帧缓冲区对象。
  3. 使用着色器程序：fboShader.use() 使用用于离屏渲染的着色器程序。
  4. 设置纹理单元：fboShader.setInt("texture0", 0) 设置着色器程序中的纹理单元。
  5. 绑定 VAO：GLES30.glBindVertexArray(vaos[0]) 绑定顶点数组对象（VAO）。
  6. 激活并绑定纹理：GLES30.glActiveTexture(GLES30.GL_TEXTURE0) 和 GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, imageTexIds[0]) 激活并绑定需要渲染的纹理。
  7. 绘制元素：GLES30.glDrawElements(GLES30.GL_TRIANGLES, indices.size, GLES30.GL_UNSIGNED_INT, 0) 使用索引数组绘制三角形。
  8. 解除绑定：解除纹理和 VAO 的绑定，以及 FBO 的绑定，恢复默认帧缓冲区。

第二步：将 FBO 的内容绘制到屏幕上

// 设置视口为屏幕尺寸
GLES30.glViewport(0, 0, screenWidth, screenHeight);

// 使用屏幕渲染的着色器程序
shader.use();

// 设置着色器程序中纹理单元的位置
shader.setInt("texture0", 0);

// 清除颜色缓冲区
GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT);

// 绑定 VAO
GLES30.glBindVertexArray(vaos[0]);

// 激活纹理单元并绑定 FBO 的纹理
GLES30.glActiveTexture(GLES30.GL_TEXTURE0);
GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, fboTexIds[0]);

// 绘制元素
GLES30.glDrawElements(GLES30.GL_TRIANGLES, indices.size, GLES30.GL_UNSIGNED_INT, 0);

// 解除 VAO 绑定
GLES30.glBindVertexArray(0);
  1. 设置视口：GLES30.glViewport(0, 0, screenWidth, screenHeight) 设置渲染区域为屏幕的尺寸。
  2. 使用着色器程序：shader.use() 使用用于屏幕渲染的着色器程序。
  3. 设置纹理单元：shader.setInt("texture0", 0) 设置着色器程序中的纹理单元。
  4. 清除颜色缓冲区：GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT) 清除颜色缓冲区。
  5. 绑定 VAO：GLES30.glBindVertexArray(vaos[0]) 绑定顶点数组对象（VAO）。
  6. 激活并绑定纹理：GLES30.glActiveTexture(GLES30.GL_TEXTURE0) 和 GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, fboTexIds[0]) 激活并绑定 FBO 的纹理（即离屏渲染的结果）。
  7. 绘制元素：GLES30.glDrawElements(GLES30.GL_TRIANGLES, indices.size, GLES30.GL_UNSIGNED_INT, 0) 使用索引数组绘制三角形。
  8. 解除绑定：解除 VAO 的绑定。

总结

  • 第一步：在 FBO 中进行离屏渲染，将结果存储在一个纹理对象中。
  • 第二步：将 FBO 中的纹理对象作为输入，绘制到屏幕上。

这种方法在图形应用程序中非常常见，特别是在实现多重渲染效果（如后期处理、反射、阴影映射等）时。

参考

芥末的无奈
关注
  • 20
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android 离屏渲染 缓冲,优化之离屏渲染
weixin_36243860的博客
05-29 1225
8种机械键盘轴体对比本人程序员，要买一个写代码的键盘，请问红轴和茶轴怎么选？这篇文章主要是总结一下我对离屏渲染的理解，之前一直不太理解离屏渲染到底是个什么，也不太理解为什么他会引起滚动界面卡顿，一直也没有去深入了解，自己也深感惭愧。以前看到了@ibireme写的iOS 保持界面流畅的技巧这篇文章，里面也描述了下屏幕显示原理。现在再次深入阅读，才比较理解离屏渲染到底是怎么回事。屏幕显示原理首先从过...
【OpenGL ES】EGL+FBO离屏渲染
04-01
本资源实现了将彩色...案例使用 EGL 代替 GLSurfaceView 生成 OpenGL ES 的渲染环境，并结合FBO实现离屏渲染，将渲染后的图片显示在 ImageView 上。博客见：https://zhyan8.blog.csdn.net/article/details/123887797
Android OpenGL ES 学习(十三) -离屏渲染FBO(截图)RBO, OES转 FBO
夏至的稻穗的博客
07-06 3454
最近遇到需要截图的功能，发现直接使用 GLES30.glReadPixels 竟然达到了2s多，且会阻塞卡顿。因此有必要学习一下 FBO 了。
探索NDKOpenGLOffscreenRendering：在Android上的离屏渲染技术实践
最新发布
gitblog_00004的博客
04-21 300
探索NDKOpenGLOffscreenRendering：在Android上的离屏渲染技术实践 项目地址:https://gitcode.com/wysaid/NDKOpenGLOffscreenRendering 项目简介 NDKOpenGLOffscreenRendering 是一个基于Android NDK和OpenGL ES的开源项目，专注于展示如何在Android平台上实现离屏渲染（O...
Android OpenGLES2.0（十二）——FBO离屏渲染
热门推荐
湖广午王
12-24 3万+
之前的博客我们所做的示例都是直接渲染到屏幕上的，如果我们并不需要渲染到屏幕上，也就是离屏渲染，该怎么做呢？FBO离屏渲染是一个很好的选择。在这篇博客中，我们将以渲染摄像头数据为例，使用FBO进行离屏渲染。 关于FBO离屏渲染 所谓的FBO就是Frame Buffer Object。之前我们使用OpenGLES渲染，都是直接渲染到屏幕上，FBO可以让我们的渲染不渲染到屏幕上，而是渲染到离屏B
Android OpenGL ES 离屏渲染（offscreen render）
weixin_33834628的博客
07-13 499
通常在Android上使用OpenGL ES，都是希望把渲染后的结果显示在屏幕上，例如图片处理、模型显示等。这种情况下，只需要使用Android API中提供的GLSurfaceView类和Renderer类，在这两个类提供的初始化、回调函数中设置/编写相应的代码即可。不过，如果不希望把渲染结果显示在屏幕上，也就是所说的离屏渲染（offscreen render），这两个类就帮不上忙了。在此介绍一...
Android OpenGL ES从白痴到入门(四):离屏渲染(Pbuffer)
zjy764219923的专栏
09-01 3113
注:涉及太专业的知识请自行保留怀疑态度！ 一本正经的胡说八道 上一节我们只是把情丝斩断了，还是没偷偷摸摸的干点见不得人的事，这节我们就来吧！ 首先，我们来看EGL创建EGLSurface有三个方法：eglCreateWindowSurface()、eglCreatePbufferSurface()和eglCreatePixmapSurface()。这三者有什么不同呢？ WindowSurface 顾名思义WindowSurface是和窗口相关的，也就是在屏幕上的一块显示区的封装，渲染后即显示在界面上
android 离屏渲染 简单书,Android OpenGL ES 8.FrameBuffer离屏渲染
weixin_39641463的博客
05-31 259
作用FrameBuffer Object,也称FBO，离屏渲染，可以摆脱屏幕的束缚，在后台做图像处理。理解FrameBuffer和Texture绑定，FrameBuffer犹如画板，而Texture犹如画纸，我们在上面画东西，画完后，我们可以拿Texture去绘制到其他地方上面。(本文重点：这个是我个人对FBO的理解，也是帮助我去使用它的方式。如果有更好的理解方式，可以留言沟通。)代码本章案例效果...
【OpenGL ES】离屏渲染
03-30
本资源使用 OpenGL ES 的 FBO 技术实现离屏渲染，使用 ImageView 显示离屏渲染后的图片（将原图片变灰）。博客见：https://zhyan8.blog.csdn.net/article/details/123749012
NDK调用OpenGL使用Camera2进行相机黑白滤镜预览（FBO离屏渲染）
01-05
FBO（Frame Buffer Object）是OpenGL的一个特性，它允许开发者在GPU上创建离屏渲染的目标。在这个场景中，NDK调用OpenGL与Camera2 API结合，实现了一个具有黑白滤镜的相机预览效果。 首先，我们来理解Camera2 API。...
OPENGL ES 3.0编程指南.pdf
04-30
OpenGL ES 3.0编程指南是面向初学者的优秀教程，旨在帮助读者深入理解并掌握OpenGL ES 3.0这一移动设备和嵌入式系统上的图形处理标准。OpenGL ES（Embedded Systems）是OpenGL的轻量级版本，专为资源有限但需要高...
离屏渲染(Pbuffer)-附件资源
03-02
离屏渲染(Pbuffer)-附件资源
OPENGL离屏渲染简单例子
12-10
使用framebuffer的OPENGL离屏渲染
OpenGL实现离屏渲染(Offscreen Render),
12-30
这是一个初级的OpenGL程序Demo，实现了Offscreen Render，在VS下可以直接运行，拖动鼠标右键可以实现内正方体的转动，拖动鼠标左键可以实现外正方体的转动；适合初学OpenGL
opengles 3.0游戏开发(上)
05-25
4. **帧缓冲对象（FBO）**：增强了对离屏渲染的支持，可用于后期处理和多重渲染目标。 5. **计算着色器**：类似GPU编程，可以执行通用计算任务，比如物理模拟或图像处理。 6. **增加顶点和片段着色器的最大输入/输出...
Android OpenGL ES 3.0 FBO 离屏渲染
风的轨迹
11-24 1485
FBO：Frame Buffer Object，即帧缓冲区对象，实际上是一个可添加缓冲区的容器，可以为其添加纹理和缓冲区对象。FBO本身不能用于渲染，只有添加了纹理或者渲染缓冲区之后才能作为渲染目标，仅提供三种附着，颜色附着、深度附着、模板附着。
OpenGL ES学习教程 --- FBO
jackzhouyu的专栏
07-19 744
OpenGL ES学习教程 — FBO 简介之什么是FBO Frame Buffer Object帧缓冲对象，按照之前的学习绘制图像、纹理，着色器着色后最后一步，会将所有的数据都传给FBO，然后在屏幕上显示，只不过没使用自定义FBO之前都是使用默认的FBO，这个FBO id为0；使用我们自定义的FBO，绑定激活后，后续的渲染操作都会传递到这个FBO上，而且这个FBO不会显示屏幕上，我们可以对这个F...
Android屏幕渲染
It一zhai男
06-20 651
目录1 相关知识点2 渲染机制2.1 渲染流程参考文章 1 相关知识点 CPU：中央处理器，它集成了运算、缓冲、控制单元包括绘图功能等。CUP将对象处理为多维图形、纹理（Bitmaps，Drawables等都是一起打包到统一的纹理）。 GPU：一个类似于CPU的专门用来处理图形的处理器，作用是用来帮助快速栅格化操作，GPU也有相应的缓存数据（例如缓存已经栅格化的bitmap等）机制。 OpenG...
四、深入剖析【离屏渲染】原理
lin1109221208的博客
07-07 1429
深入剖析【离屏渲染】原理 离屏渲染与正常渲染 屏幕上最终显示的数据有两种加载流程 正常渲染加载流程 离屏渲染加载流程 从图上看，他们之间的区别就是离屏渲染比正常渲染多了一个离屏缓冲区，这个缓冲区的作用是什么呢？下面来仔细说说 首先，说说正常渲染流程 正常渲染流程 APP中的数据经过CPU计算和GPU渲染后，将结果存放在帧缓冲区，利用视频控制器从帧缓冲区中取出，并显示到屏幕上。 在GPU的渲染流程中，显示到屏幕上的图像是遵循大画家算法按照由远及近的顺序，依次将结果存储到帧缓冲区 视屏控制器从帧缓冲区中
OpenGLES3.0实现为视频数据离屏渲染
09-26
### 回答1： OpenGLES 3.0是一个用于移动设备的图形渲染API，可以用来渲染3D图形和动画。要实现视频数据离屏渲染，可以按照以下步骤： 1.创建一个FBO(Frame Buffer Object)。FBO是一个特殊的OpenGL对象，它可以将渲染结果存储到一个纹理或者渲染缓冲区中。 2.创建一个纹理对象，用来存储渲染结果。将纹理对象作为FBO的颜色附件绑定到FBO上。 3.将FBO绑定到OpenGL上下文中。 4.创建一个渲染程序(Program)，用于将视频数据渲染到FBO中。该渲染程序应该包含一个顶点着色器(Vertex Shader)和一个片元着色器(Fragment Shader)。 5.将视频数据上传到纹理对象中。 6.设置顶点和纹理坐标，将视频数据渲染到FBO中。 7.将FBO从OpenGL上下文中解绑。 8.从纹理对象中获取渲染结果数据。 9.销毁FBO、纹理对象和渲染程序。 以上步骤需要使用OpenGL ES 3.0的相关函数和常量进行操作，具体实现可以参考OpenGL ES 3.0的相关文档和示例代码。 ### 回答2： OpenGLES（OpenGL for Embedded Systems）是一种针对嵌入式系统的2D和3D图形API。OpenGLES 3.0是OpenGLES的一个版本，它引入了更多的功能和更高的性能，以满足现代移动设备和嵌入式系统对图形渲染的需求。 要实现为视频数据进行离屏渲染，首先需要获取视频数据。可以通过各种方式获取视频数据，例如从文件中读取、网络传输等等。获取到视频数据后，就可以进行渲染操作了。 接下来，需要创建一个离屏渲染的环境。在OpenGLES中，可以通过创建一个离屏帧缓冲对象（FBO）来实现离屏渲染。离屏帧缓冲对象可以将渲染结果存储在纹理或渲染缓冲中。 创建离屏帧缓冲对象后，需要将其绑定为当前的渲染目标。这样，所有的渲染操作将会在离屏帧缓冲对象中进行，而不是直接渲染到屏幕上。可以使用glBindFramebuffer函数来绑定离屏帧缓冲对象。 一旦离屏帧缓冲对象被绑定，就可以通过OpenGL ES的渲染管线来进行渲染操作了。可以使用顶点缓冲对象、着色器程序和纹理等来设置渲染的属性和效果。可以使用glDrawArrays或glDrawElements函数来执行渲染操作。 渲染完成后，可以将离屏帧缓冲对象中的渲染结果存储在纹理中，或者将其拷贝到其他地方，例如内存或文件中。可以使用glFramebufferTexture2D或glReadPixels函数来实现这些操作。 最后，需要清除和释放离屏渲染所使用的资源，例如离屏帧缓冲对象、纹理和顶点缓冲对象等。可以使用glDeleteFramebuffers、glDeleteTextures和glDeleteBuffers函数来释放相应的资源。 通过以上步骤，就可以使用OpenGLES 3.0实现为视频数据进行离屏渲染。这样可以将渲染结果用于后续的处理、保存或显示等用途。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值