最通俗的安卓OpenGL教学07——使用FBO

已于 2023-10-17 10:08:15 修改
阅读量1.1k 收藏 4
点赞数
分类专栏： OpenGL ES 文章标签： android
于 2020-12-21 21:56:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/york2017/article/details/111500883
版权

当需要对纹理进行多次渲染时，而这些渲染采样是不需要展示给用户看的，就可以用一个单独的缓冲对象（离屏渲染）
来存储多次渲染采样的结果，等处理完后再显示到窗口上。

FBO的创建有以下步骤：

  1. 创建FBO
  2. 绑定FBO
  3. 设置FBO分配内存大小
  4. 把纹理绑定到FBO
  5. 检查FBO绑定是否成功
  6. 解绑FBO

FBO的使用有以下步骤：

  1. 绑定FBO
  2. 获取需要绘制的图片纹理，然后绘制渲染
  3. 解绑FBO
  4. 把绑定到FBO的纹理绘制渲染出来

1. FBO的创建

在onSurfaceCreated时创建：

  		//创建 fbo
        int[] fbo_s = new int[1];
        GLES20.glGenBuffers(1, fbo_s, 0);
        fbo = fbo_s[0];
        //使 fbo 成为 fbo对象  GL_FRAMEBUFFER
        GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, fbo);

        //创建 1个 fbo 纹理 fboTextureID
        int[] textureIds = new int[1];
        GLES20.glGenTextures(1, textureIds, 0);//第三个参数是指从哪儿开始取
        fboTextureID = textureIds[0];
        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, fboTextureID);// 在没设置点的情况下默认是绑定 0号纹理

        //设置纹理的环绕方式
        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_REPEAT);
        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_REPEAT);
        //设置纹理的过滤方式
        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_LINEAR);
        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR);

2.使用FBO

在onDrawFrame时使用：

 		//绑定 fbo 开始使用 FBO
        GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, fbo);

        //绑定 imgTextureId 开始使用纹理
        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, imgTextureId);
        //绘制
        GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4);
        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, 0);
        //解绑 FBO纹理
        GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, 0);

        yFboRender.onDraw(fboTextureID);

3. 完整代码

package com.york.media.opengl.demo.fbo;

import android.content.Context;
import android.opengl.GLES20;
import com.york.media.opengl.R;
import com.york.media.opengl.egl.TextureUtils;
import com.york.media.opengl.egl.YGLSurfaceView;
import com.york.media.opengl.egl.YShaderUtil;
import com.york.media.opengl.utils.LogUtil;

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;

/**
 * author : York
 * date   : 2020/12/20 19:42
 * desc   : FBO 帧缓冲对象
 * <p>
 * 当需要对纹理进行多次渲染时，而这些渲染采样是不需要展示给用户看的，就可以用一个单独的缓冲对象（离屏渲染）
 * 来存储多次渲染采样的结果，等处理完后再显示到窗口上。
 */
public class YUsedFboRender implements YGLSurfaceView.YGLRender {

    private final Context mContext;
    private final FloatBuffer vertexBuffer;
    private final FloatBuffer fragmentBuffer;
    private int program;
    private int vPosition;
    private int fPosition;

    private int fboTextureID;
    private int vbo;
    private int fbo;

    private int imgTextureId;
    private int fboWidth;
    private int fboHeight;

    private final YFboRender yFboRender;
    //顶点坐标
    float[] vertexData = {
            -1f, -1f,
            1f, -1f,
            -1f, 1f,
            1f, 1f
    };

    //纹理坐标
    float[] fragmentData = {
            0f, 1f,
            1f, 1f,
            0f, 0f,
            1f, 0f
    };


    public YUsedFboRender(Context context, int width, int height) {
        this.mContext = context;
        fboWidth = width;
        fboHeight = height;
        yFboRender = new YFboRender(context);
        //读取顶点坐标
        vertexBuffer = ByteBuffer.allocateDirect(vertexData.length * 4).order(ByteOrder.nativeOrder()).asFloatBuffer().put(vertexData);
        vertexBuffer.position(0);

        //读取纹理坐标
        fragmentBuffer = ByteBuffer.allocateDirect(fragmentData.length * 4).order(ByteOrder.nativeOrder()).asFloatBuffer().put(fragmentData);
        fragmentBuffer.position(0);

    }

    @Override
    public void onSurfaceCreated() {
        yFboRender.onCreate();

        //加载顶点着色器 shader
        String vertexSource = YShaderUtil.getRawResource(mContext, R.raw.screen_vert);
        //加载片元着色器 shader
        String fragmentSource = YShaderUtil.getRawResource(mContext, R.raw.screen_frag);
        //获取源程序
        program = YShaderUtil.createProgram(vertexSource, fragmentSource);
        //从渲染程序中得到着顶点色器中的属性
        vPosition = GLES20.glGetAttribLocation(program, "vPosition");
        //从渲染程序中得到片元着色器中的属性
        fPosition = GLES20.glGetAttribLocation(program, "fPosition");
        //创建 VBO
        int[] vbo_s = new int[1];
        GLES20.glGenBuffers(1, vbo_s, 0);
        vbo = vbo_s[0];
        //绑定 VBO
        GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, vbo);

        //分配 VBO需要的缓存大小
        GLES20.glBufferData(GLES20.GL_ARRAY_BUFFER, vertexData.length * 4 + fragmentData.length * 4, null, GLES20.GL_STATIC_DRAW);
        //设置顶点坐标数据的值到 VBO
        GLES20.glBufferSubData(GLES20.GL_ARRAY_BUFFER, 0, vertexData.length * 4, vertexBuffer);
        //设置纹理坐标数据的值到 VBO
        GLES20.glBufferSubData(GLES20.GL_ARRAY_BUFFER, vertexData.length * 4, fragmentData.length * 4, fragmentBuffer);
        //解绑 VBO，指的是离开对 VBO的配置，进入下一个状态
        GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, 0);

        //创建 fbo
        int[] fbo_s = new int[1];
        GLES20.glGenBuffers(1, fbo_s, 0);
        fbo = fbo_s[0];
        //使 fbo 成为 fbo对象  GL_FRAMEBUFFER
        GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, fbo);

        //创建 1个 fbo 纹理 fboTextureID
        int[] textureIds = new int[1];
        GLES20.glGenTextures(1, textureIds, 0);//第三个参数是指从哪儿开始取
        fboTextureID = textureIds[0];
        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, fboTextureID);// 在没设置点的情况下默认是绑定 0号纹理

        //设置纹理的环绕方式
        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_REPEAT);
        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_REPEAT);
        //设置纹理的过滤方式
        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_LINEAR);
        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR);

        LogUtil.d("fbo_Width=" + fboWidth + ",fboHeight=" + fboHeight);
        //分配FBO内存大小
        GLES20.glTexImage2D(GLES20.GL_TEXTURE_2D, 0, GLES20.GL_RGBA, fboWidth, fboHeight, 0, GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE, null);
        //把 2D纹理 fboTextureID 绑定到 FBO 对象
        GLES20.glFramebufferTexture2D(GLES20.GL_FRAMEBUFFER, GLES20.GL_COLOR_ATTACHMENT0, GLES20.GL_TEXTURE_2D, fboTextureID, 0);
        //检查FBO绑定是否成功
        if (GLES20.glCheckFramebufferStatus(GLES20.GL_FRAMEBUFFER) != GLES20.GL_FRAMEBUFFER_COMPLETE) {
            LogUtil.e("fbo bind error !");
        }

        //绑定纹理到 fbo成功后 退出纹理绑定，进入下一环节
        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, 0);

        imgTextureId = TextureUtils.createImageTexture(mContext, R.drawable.nobb);

    }

    @Override
    public void onSurfaceChanged(int width, int height) {
        //设置窗口大小
        GLES20.glViewport(0, 0, width, height);
        fboWidth = width;
        fboHeight = height;
        yFboRender.onChange(fboWidth, fboHeight);
    }

    @Override
    public void onDrawFrame() {
        //清除屏幕，此处用的是红色
        GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);
        GLES20.glClearColor(1f, 0f, 0f, 1f);
        //使用着色器源程序
        GLES20.glUseProgram(program);

        //开始使用 VBO
        GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, vbo);
        //使能顶点属性数组，使之有效
        GLES20.glEnableVertexAttribArray(vPosition);
        //使能之后，为顶点属性赋值，从VBO里获取 绑定顶点坐标; 注意：最后一个参数如果是 vertexBuffer，那么就没有用到 VBO，那就还是从CPU里取顶点
        GLES20.glVertexAttribPointer(vPosition, 2, GLES20.GL_FLOAT, false, 8, 0);
        //使能片元属性数组，使之有效
        GLES20.glEnableVertexAttribArray(fPosition);
        //使能之后，为片元属性赋值，从VBO里获取 绑定纹理坐标; 注意：最后一个参数为 VBO里的偏移量
        GLES20.glVertexAttribPointer(fPosition, 2, GLES20.GL_FLOAT, false, 8, vertexData.length * 4);
        //退出 VBO的使用
        GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, 0);

        //绑定 fbo 开始使用 FBO
        GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, fbo);

        //绑定 imgTextureId 开始使用纹理
        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, imgTextureId);
        //绘制
        GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4);
        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, 0);
        //解绑 FBO纹理
        GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, 0);

        yFboRender.onDraw(fboTextureID);

    }
}


package com.york.media.opengl.demo.fbo;

import android.content.Context;
import android.opengl.GLES20;

import com.york.media.opengl.R;
import com.york.media.opengl.egl.YShaderUtil;

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;

/**
 * author : York
 * date   : 2020/12/20 20:29
 * desc   :
 */
public class YFboRender {

    private final Context context;
    private final FloatBuffer vertexBuffer;
    private final FloatBuffer fragmentBuffer;
    private int vPosition;
    private int fPosition;
    private int program;
    private int vbo;


    private final float[] vertexData = {
            -1f, -1f,
            1f, -1f,
            -1f, 1f,
            1f, 1f
    };
    //因为 fbo的片元坐标系与安卓的不一样，所以看上去是倒的
    private final float[] fragmentData = {
            0f, 0f,
            1f, 0f,
            0f, 1f,
            1f, 1f
    };

    public YFboRender(Context context) {
        this.context = context;

        vertexBuffer = ByteBuffer.allocateDirect(vertexData.length * 4)
                .order(ByteOrder.nativeOrder())
                .asFloatBuffer()
                .put(vertexData);
        vertexBuffer.position(0);

        fragmentBuffer = ByteBuffer.allocateDirect(fragmentData.length * 4)
                .order(ByteOrder.nativeOrder())
                .asFloatBuffer()
                .put(fragmentData);
        fragmentBuffer.position(0);

    }

    public void onCreate() {

        String vertexSource = YShaderUtil.getRawResource(context, R.raw.screen_vert);
        String fragmentSource = YShaderUtil.getRawResource(context, R.raw.screen_frag);

        program = YShaderUtil.createProgram(vertexSource, fragmentSource);

        vPosition = GLES20.glGetAttribLocation(program, "vPosition");
        fPosition = GLES20.glGetAttribLocation(program, "fPosition");

        int[] vbo_s = new int[1];
        GLES20.glGenBuffers(1, vbo_s, 0);
        vbo = vbo_s[0];

        GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, vbo);
        GLES20.glBufferData(GLES20.GL_ARRAY_BUFFER, vertexData.length * 4 + fragmentData.length * 4, null, GLES20.GL_STATIC_DRAW);
        GLES20.glBufferSubData(GLES20.GL_ARRAY_BUFFER, 0, vertexData.length * 4, vertexBuffer);
        GLES20.glBufferSubData(GLES20.GL_ARRAY_BUFFER, vertexData.length * 4, fragmentData.length * 4, fragmentBuffer);
        GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, 0);
    }

    public void onChange(int width, int height) {
        GLES20.glViewport(0, 0, width, height);
    }

    public void onDraw(int textureId) {

        GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);
        GLES20.glClearColor(0f, 1f, 0f, 1f);
        GLES20.glUseProgram(program);
        //使用 vbo
        GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, vbo);
        GLES20.glEnableVertexAttribArray(vPosition);
        GLES20.glVertexAttribPointer(vPosition, 2, GLES20.GL_FLOAT, false, 8, 0);
        GLES20.glEnableVertexAttribArray(fPosition);
        GLES20.glVertexAttribPointer(fPosition, 2, GLES20.GL_FLOAT, false, 8, vertexData.length * 4);
        //解绑vbo，退出使用vbo 进入下一环节，绘制纹理
        GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, 0);

        //绑定纹理
        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, textureId);
        //绘制纹理
        GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4);
        //解绑纹理
        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, 0);

    }
}

效果依旧杠杠滴：

york2017
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android OpenGL ES 总结之FBO
m0_37884055的博客
10-13 143
别人都说计算机图形学是程序员的浪漫，但是作为一个天赋不高的普通码农，只能一遍又一遍的硬啃具体实现，这东西太麻烦了，单单只是绘制一个三角形，就要写一堆代码，然后不写又记不住具体步骤。因此，你首先不是在默认的帧缓冲中渲染原始纹理，而是在FBO中渲染原始纹理，这样结果就保存在fboTextureId中。因为工作上用到了OpenGL ES，不得不从头开始学OpenGL，虽说之前有看过图形学相关的，但是理论太抽象了，还是要实践。总的来说，帧缓冲对象允许你将渲染的结果重定向到纹理，而不是直接输出到屏幕。
Android OpenGL ES 学习(十三) -离屏渲染FBO(截图)RBO, OES转 FBO
夏至的稻穗的博客
07-06 3464
最近遇到需要截图的功能，发现直接使用 GLES30.glReadPixels 竟然达到了2s多，且会阻塞卡顿。因此有必要学习一下 FBO 了。
LearnOpenGL - Android OpenGL ES 3.0 使用 FBO 进行离屏渲染
最新发布
记录学习的过程
06-27 1094
利用 FBO（Framebuffer Object），我们可以实现离屏渲染。在前面的章节中，当我们调用 glDrawElements 后，手机屏幕上就会显示出绘制的图像。这意味着 OpenGL 将数据直接渲染到了手机屏幕上。通过使用 FBO，我们可以将数据渲染到纹理上，而不是直接渲染到屏幕，这个过程称为离屏渲染。通过离屏渲染，我们可以在最终显示之前对图像进行复杂的处理。这种方法非常有用，比如在后期处理效果（如模糊、HDR、阴影等）中，或者在渲染多个场景以进行纹理贴图、环境映射等操作时。
OpenGL基本图形的绘制———VS2022
m0_65939341的博客
11-28 1102
用OpenGL中的函数绘制基本的图形——茶壶、四面体、立方体、球体、圆锥等
openGL绘制图形
wangjie36的博客
02-18 586
接下来，通过glCreateProgram函数创建着色器程序对象，使用g1AttachShader函数将顶点着色器和片段着色器附加到着色器程序对象上，使用glLinkProgram函数链接着色器程序，使用glUseProgram函数激活着色器程序。首先，定义绘制图形的函数（在OpenGL的绘制回调函数中调用）和OpenGL的初始化函数（用来设置OpenGL的参数和状态）。在OpenGL中，可以回调函数处理用户输入事件，如键盘事件和鼠标事件和上下左右。主函数用来创建窗口和注册OpenGL的回调函数。
Android OpenGL 教程——Native 工程初始化
xyTianZhao
07-21 559
Native 工程初始化
android平台opengl es读取纹理数据并保存图片
XR风云
02-22 4311
在AR云渲染服务中，有时候需要把生成的纹理保存到图片来进行调试。 那就想办法看看存成图片，很多人说用glGetTexImage这个函数可以直接读取纹理的数据，但是我们用到了opengl es 32版本，不支持这个函数，想了办法，把纹理绑定到framebuffer，然后用glReadPixels读取出来，然后在保存图片。 具体实现如下： private void saveRgb2Bitmap(Buffer buf, String filename, int width, int height)
android 下怎样获取图片像素值
ruanjianxiong的专栏
08-25 9989
int[] pixels = new int[bit.getWidth()*bit.getHeight()];//保存所有的像素的数组，图片宽×高          bit.getPixels(pixels,0,bit.getWidth(),0,0,bit.getWidth
【OpenGL ES】EGL+FBO离屏渲染
04-01
本资源实现了将彩色...案例使用 EGL 代替 GLSurfaceView 生成 OpenGL ES 的渲染环境，并结合FBO实现离屏渲染，将渲染后的图片显示在 ImageView 上。博客见：https://zhyan8.blog.csdn.net/article/details/123887797
FBO.zip_FBO_OpenGL FBO_OpenGL，fbo_fbo in opengl
09-14
OpenGL Framebuffer Objects (FBO) 是一种在现代OpenGL编程中用于高效处理图形和像素操作的核心技术。FBO允许开发者创建自定义的渲染目标，比如离屏渲染、多重渲染或者复杂的后处理效果。在这个"FBO.zip"文件中，...
fbo.rar_FBO_OpenGL，fbo_opengl MRT
09-23
OpenGL中的帧缓冲对象（FBO，Framebuffer Objects）是现代图形编程中的一个重要概念，它扩展了OpenGL的渲染能力，使得开发者可以将渲染结果存储在纹理或渲染缓冲中，而非直接显示到屏幕上。FBO是OpenGL的一个核心...
fbo.zip_Fame_OpenGL，fbo
09-14
描述提到“opengl fame buffer使用例子”，这表明压缩包内的文件可能是源代码或者文档，展示了如何在实际项目中运用FBO。通过学习这个例子，开发者可以了解到如何创建、绑定、配置FBO，以及如何将颜色、深度和模板...
Opengl使用FBO实现的地球表面海洋流动效果
09-11
"Opengl使用FBO实现的地球表面海洋流动效果"是一个典型的使用OpenGL和FBO进行高级渲染的例子。这个项目可能是创建一个模拟地球表面的3D模型，并通过FBO来实现海洋表面的流动视觉效果。海洋流动通常涉及到复杂的纹理...
OpenGL缓冲区对象之FBO
翻肚鱼儿的博客
08-06 976
1. 概述 在OpenGL渲染管线中几何数据和纹理经过变换和一些测试处理，最终会被展示到屏幕上。OpenGL渲染管线的最终位置是在帧缓冲区中。帧缓冲区是一系列二维的像素存储数组，包括了颜色缓冲区、深度缓冲区、模板缓冲区以及累积缓冲区。默认情况下OpenGL使用的是窗口系统提供的帧缓冲区。 OpenGL的GL_ARB_framebuffer_object这个扩展提供了一种方式来创建额外的帧缓冲区对象（FBO）。使用帧缓冲区对象，OpenGL可以将原先绘制到窗口提供的帧缓冲区重定向到FBO之中。 和窗口提
android获取画布颜色像素点,Android绘图那些事——Canvas，Matrix，Shader
weixin_39627361的博客
05-25 840
简介Android自己的SDK提供了2D图形处理相关的API，大部分都在android.graphics和android.graphics.drawable包中。绘制2D图形，有两种方式：在layout中定义图形和动画，主要用于绘制静态图形和预先定义好的动画。直接在Canvas上绘制，一般用于需要重绘实现效果的View。根据官方文档，绘画需要4个元素协同完成To draw something, y...
Android OpenGL ES从入门到进阶（六）—— OpenGL ES人像美白与磨皮初探
liuderong0的博客
07-16 2926
框架源码：https://github.com/smzhldr/AGLFramework 一、前言 前面的章节中的内容差不多能让初学者对OpenGL 有个初步的理解，基础知识很重要但基础不是核心，我们该有新的目标了，基础部分忘了的可以复习下前几章的内容，想拓宽基础的可以参考文档或者看巨著。 这一节我们从OpenGL的实际应用出发，逐步来掌握OpenGL各种各样的功能，之后的的章节将以应用为背景，以...
OpenGL ES之离屏渲染的帧缓冲区对象FBO的说明和使用
╰つ栺尖篴夢ゞ
06-20 1274
FBO（Frame Buffer Object）即帧缓冲区对象，实际上是一个可添加缓冲区的容器，可以为其添加纹理或渲染缓冲区对象（RBO）。FBO 本身不能用于渲染，只有添加了纹理或者渲染缓冲区之后才能作为渲染目标，它仅且提供了 3 个附着（Attachment），分别是颜色附着、深度附着和模板附着。...
OpenGL 学习系列--基础的绘制流程(1)，贼好用的Android学习路线集合
wdsfgj的博客
04-03 880
最后为了帮助大家深刻理解Android相关知识点的原理以及面试相关知识，这里放上相关的我搜集整理的24套腾讯、字节跳动、阿里、百度2019-2021面试真题解析，我把技术点整理成了视频和PDF（实际上比预期多花了不少精力），包知识脉络 + 诸多细节。还有高级架构技术进阶脑图、Android开发面试专题资料帮助大家学习提升进阶，也节省大家在网上搜索资料的时间来学习，也可以分享给身边好友一起学习。
最通俗的安卓OpenGL教学09——添加水印
york2017的博客
12-21 2950
添加水印的原理主要是利用OpenGL ES绘制多次，把不同的纹理如图片、文本等绘制到纹理或窗口上，达到添加水印的效果，需要注意的地方就是要确定好需要在屏幕上绘制的位置坐标。 添加水印的原理： 利用OpenGL ES绘制多次，把不同的纹理如图片、文本等绘制到纹理或窗口上，达到添加水印的效果。 图片水印，直接绑定bitmap到纹理； 文字水印，先将文字转为bitmap，再绑定到纹理。 先看效果： 添加水印的步骤： 首先确认水印添加的位置 设置水印的大小 根据水印图片长宽比计算水印的顶点坐标 接下.
android opengl学习
03-30
学习OpenGL ES（Embedded Systems）可以让你在Android平台上构建高性能的2D和3D图形应用程序。以下是一些学习OpenGL ES的步骤和建议： 1. 了解OpenGL ES的基础知识：OpenGL ES是一个跨平台的图形API，用于在移动设备上进行高性能的2D和3D绘图。在学习OpenGL ES之前，建议先了解OpenGL ES的基础知识，例如图形管线、着色器、顶点缓冲区对象（VBO）等。 2. 学习OpenGL ES的编程语言：OpenGL ES支持多种编程语言，包括C、C++、Java等。对于Android开发者来说，Java是最常用的编程语言。 3. 下载OpenGL ES开发工具：为了开始学习OpenGL ES，需要安装一个开发环境。Android Studio是一个常用的Android开发工具，可以通过安装Android Studio来获取OpenGL ES的开发环境。 4. 学习OpenGL ES的API：OpenGL ES有许多的API可以使用，例如OpenGL ES 1.0、OpenGL ES 2.0、OpenGL ES 3.0等。建议从OpenGL ES 2.0开始学习，因为它支持现代的图形管线和着色器编程。 5. 掌握OpenGL ES的基本概念和技术：学习OpenGL ES的一些基本概念和技术包括着色器编程、渲染缓冲区对象（RBO）、帧缓冲区对象（FBO）等。 6. 实践：最好的学习方法是通过实践来掌握OpenGL ES。可以通过编写简单的图形应用程序来加深对OpenGL ES的理解和掌握。 7. 学习OpenGL ES的高级技术：一旦掌握了基本概念和技术，可以开始学习OpenGL ES的高级技术，例如纹理映射、光照、阴影等。 总之，学习OpenGL ES需要掌握基本概念和技术，并通过实践来加深理解。此外，需要耐心和毅力，因为OpenGL ES是一个复杂的主题，需要花费时间和精力来学习。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值